?um/p1-9在 https://tc39.es/ecma262/ 上的文档是最准确和最新的ECMAScript规范。它包含了最新年度快照的内容以及任何已完成的提案(那些在提案流程中达到第4阶段并因此在多个实现中实现且将在下一次实际修订中包含的提案)自该快照以来的内容。
此规范在GitHub上由ECMAScript社区的帮助下开发。有多种方式可以为此规范的发展做出贡献:
有关如何创建此文档的更多信息,请参阅
此ecma标准定义了ECMAScript 2024语言。它是ECMAScript语言的第十五版 规范。自1997年第一版出版以来,ECMAScript已发展成为世界上 最广泛使用的通用编程语言。它最为人所知的是嵌入在网络中的语言 浏览器,但也被广泛用于服务器和嵌入式应用程序。
ECMAScript基于几种原始技术,最著名的是JavaScript(Netscape)和 JScript(微软)。该语言由Netscape的Brendan Eich发明,首次出现在该公司的 Navigator 2.0浏览器。它已出现在Netscape的所有后续浏览器和Netscape的所有浏览器中 Microsoft从Internet Explorer 3.0开始。
ECMAScript语言规范的开发始于1996年11月。这个的第一版 ECMA标准于1997年6月由ECMA大会通过。
该ECMA标准已提交给ISO/IEC JTC 1以供快速通道程序采用,并被批准为 国际标准ISO/IEC 16262,1998年4月。ECMA大会于1998年6月批准了第二个 ECMA-262版本,使其完全符合ISO/IEC 16262。第一个和第二个之间的变化 版本本质上是编辑性的。
标准第三版引入了强大的正则表达式、更好的字符串处理、新的控件 语句、try/catch异常处理、更严格的错误定义、数字输出的格式和次要 对未来语言增长的预期变化。ECMAScript标准的第三版被 1999年12月的ECMA大会,并于2002年6月作为ISO/IEC 16262:2002发布。
第三版发布后,ECMAScript与全球广泛采用 Web,它已成为基本上所有Web浏览器都支持的编程语言。重要的 开发ECMAScript第四版的工作已经完成。然而,这项工作没有完成,也没有出版 作为ECMAScript的第四版,但其中一些被纳入了第六版的开发。
ECMAScript第五版(作为ECMA-262 5th版发布)事实上已编纂
对浏览器实现中常见的语言规范的解释并添加了
支持自第三版出版以来出现的新功能。这些功能包括
第五版提交给ISO/IEC JTC 1采用快速通道程序,并被批准为国际标准ISO/IEC 16262:2011。ECMAScript标准的5.1版包含了一些小的修正,文本与ISO/IEC 16262:2011相同。5.1版于2011年6月被Ecma大会采纳。
第六版的集中开发始于2009年,当时第五版正在准备出版。然而,在此之前,自1999年第三版发布以来,已经进行了大量的实验和语言增强设计工作。从某种意义上说,第六版的完成是十五年努力的结晶。本版的目标包括提供对大型应用程序、库创建的更好支持,并将ECMAScript用作其他语言的编译目标。其主要增强功能包括模块、类声明、词法块作用域、迭代器和生成器、用于异步编程的Promises、解构模式和正确的尾调用。ECMAScript内置库扩展了对附加数据抽象的支持,包括地图、集合和二进制数值数组,并在字符串和正则表达式中增加了对Unicode补充字符的支持。内置库还通过子类化变得可扩展。第六版为常规的、增量的语言和库增强提供了基础。第六版于2015年6月被大会采纳。
ECMAScript 2016是Ecma TC39在新的年度发布节奏和开放开发流程下发布的第一个ECMAScript版本。从ECMAScript
2015源文档生成了一个纯文本源文档,作为在GitHub上进一步开发的基础。在这一标准的开发过程中,提交了数百个拉取请求和问题,代表了成千上万个错误修复、编辑修正和其他改进。此外,还开发了许多软件工具来帮助这一工作,包括Ecmarkup、Ecmarkdown和Grammarkdown。ES2016还包括对新幂运算符的支持,并在Array.prototype中添加了一个名为includes的新方法。
ECMAScript 2017引入了异步函数、共享内存和原子操作,以及一些较小的语言和库增强、错误修复和编辑更新。异步函数通过提供Promise返回函数的语法来改进异步编程体验。共享内存和原子操作引入了一种新的内存模型,允许多代理程序使用原子操作进行通信,即使在并行CPU上也能确保定义明确的执行顺序。它还包括Object上的新静态方法:Object.values、Object.entries和Object.getOwnPropertyDescriptors。
ECMAScript
2018通过AsyncIterator协议和异步生成器引入了对异步迭代的支持。它还包括四个新的正则表达式特性:dotAll标志、命名捕获组、Unicode属性转义和后行断言。最后,它还包括对象的剩余和扩展属性。
ECMAScript
2019引入了一些新的内置函数:Array.prototype上的flat和flatMap用于扁平化数组,Object.fromEntries用于直接将Object.entries的返回值转化为新对象,以及String.prototype上的trimStart和trimEnd作为更好命名的替代方案,取代广泛实现但非标准的String.prototype.trimLeft和trimRight内置函数。此外,它还包括一些语法和语义的较小更新。更新的语法包括可选的catch绑定参数,并允许在字符串字面量中使用U+2028(行分隔符)和U+2029(段落分隔符)以与JSON保持一致。其他更新包括要求Array.prototype.sort为稳定排序,要求JSON.stringify无论输入如何都返回格式良好的UTF-8,以及通过要求Function.prototype.toString返回相应的原始源文本或标准占位符来进行明确。
ECMAScript
2020,第11版,引入了字符串的matchAll方法,用于生成全局正则表达式匹配对象的迭代器;import()语法,用于动态异步导入模块;BigInt,一种新的数字原始类型,用于处理任意精度的整数;Promise.allSettled,一种新的Promise组合器,不会短路;globalThis,一种通用的全局this值访问方式;专用的export * as ns from 'module'语法,用于模块内;增加了for-in枚举顺序的标准化;import.meta,一个由宿主填充的对象,包含关于模块的上下文信息;以及为处理“nullish”值(
ECMAScript
2021,第12版,引入了字符串的replaceAll方法;Promise.any,一个在输入值被实现时短路的Promise组合器;AggregateError,一种新错误类型,用于同时表示多个错误;逻辑赋值操作符(??=、&&=、||=);WeakRef,用于引用目标对象而不保留其免于垃圾回收,以及FinalizationRegistry,用于管理在目标对象被垃圾回收时执行的清理操作的注册和取消注册;数字字面量的分隔符(1_000);并且使Array.prototype.sort更加精确,减少了导致
ECMAScript 2022,第13版,引入了顶层await,允许在模块顶层使用关键字;新的类元素:公共和私有实例字段、公共和私有静态字段、私有实例方法和访问器、以及私有静态方法和访问器;类中的静态块,用于每类评估初始化;#x in obj语法,用于测试对象上私有字段的存在;通过/d标志的正则表达式匹配索引,提供匹配子字符串的起始和结束索引;Error对象上的cause属性,用于记录错误中的因果链;用于字符串、数组和类型化数组的at方法,允许相对索引;以及Object.hasOwn,Object.prototype.hasOwnProperty的便捷替代。
ECMAScript
2023,第14版,引入了Array.prototype和TypedArray.prototype上的toSorted、toReversed、with、findLast和findLastIndex方法,以及Array.prototype上的toSpliced方法;增加了对文件开头#!注释的支持,以更好地促进可执行ECMAScript文件;并允许在弱集合中使用大多数符号作为键。
ECMAScript
2024,第15版,增加了调整和转移ArrayBuffers和SharedArrayBuffers大小的功能;添加了用于创建具有更高级功能的字符串集的RegExp/v标志;引入了用于构建Promise的便捷方法Promise.withResolvers、用于数据聚合的Object.groupBy和Map.groupBy方法、用于异步等待共享内存更改的Atomics.waitAsync方法,以及用于检查和确保字符串仅包含格式良好的Unicode的String.prototype.isWellFormed和String.prototype.toWellFormed方法。
代表许多组织的数十个人在Ecma TC39中对这一版本的开发以及之前的版本做出了非常重要的贡献。此外,还出现了一个支持TC39的ECMAScript工作的活跃社区。这个社区审查了无数草案,提交了数千个错误报告,进行了实现实验,贡献了测试套件,并向全球开发者社区介绍了ECMAScript。不幸的是,不可能识别和感谢每一个为这项工作做出贡献的人和组织。
Allen Wirfs-Brock
ECMA-262,第六版项目编辑
Brian Terlson
ECMA-262,第七版至第十版项目编辑
Jordan Harband
ECMA-262,第十版至第十二版项目编辑
Shu-yu Guo
ECMA-262,第十二版至第十五版项目编辑
Michael Ficarra
ECMA-262,第十二版至第十五版项目编辑
Kevin Gibbons
ECMA-262,第十二版至第十五版项目编辑
本标准定义了ECMAScript 2024通用编程语言。
符合ECMAScript规范的实现必须提供并支持本规范中描述的所有类型、值、对象、属性、函数和程序语法及语义。
符合ECMAScript规范的实现必须按照最新版本的Unicode标准和ISO/IEC 10646解释源文本输入。
提供支持不同语言和国家的语言和文化习俗的应用编程接口(API)的符合ECMAScript规范的实现必须实现ECMA-402最新版本中与本规范兼容的接口。
符合ECMAScript规范的实现可以提供本规范中未描述的其他类型、值、对象、属性和函数。特别是,符合ECMAScript规范的实现可以为本规范中描述的对象提供本规范中未描述的属性和值。
符合ECMAScript规范的实现可以支持本规范中未描述的程序和正则表达式语法。特别是,符合ECMAScript规范的实现可以支持使用本规范第
符合ECMAScript规范的实现不得实现本规范第
符合ECMAScript规范的实现不得重新定义任何不是
符合ECMAScript规范的实现可以选择实现或不实现规范性可选的小节。如果实现了任何规范性可选行为,则必须实现包含的规范性可选条款中的所有行为。本规范中用彩色框中的“规范性可选”一词来表示规范性可选条款,如下所示。
示例条款内容。
符合ECMAScript规范的实现必须实现遗留小节,除非它们也被标记为规范性可选。遗留小节中指定的所有语言特性和行为都具有一个或多个不理想的特性。然而,它们在现有应用程序中的持续使用阻止了它们从本规范中删除。这些特性不被视为ECMAScript核心语言的一部分。程序员在编写新的ECMAScript代码时不应使用或假设这些特性和行为的存在。
示例条款内容。
示例条款内容。
下列引用文件对于本文档的应用是必不可少的。对于有日期的引用,仅适用于所引用的版本。对于无日期的引用,适用于引用文件的最新版本(包括任何修正案)。
Unicode 标准。
https://unicode.org/versions/latest
ISO/IEC 10646,信息技术 — 通用多八位编码字符集 (UCS) 加上修正案1:2005、修正案2:2006、修正案3:2008、修正案4:2008和其他修正案和勘误,或其后续版本。
ECMA-402,ECMAScript 国际化 API 规范,特别是与本规范版本相对应的年度版。
https://www.ecma-international.org/publications-and-standards/standards/ecma-402/
ECMA-404,JSON 数据交换格式。
https://www.ecma-international.org/publications-and-standards/standards/ecma-404/
本节包含 ECMAScript 语言的非规范性概述。
ECMAScript 是一种面向对象的编程语言,用于在 宿主环境 中执行计算和操作计算对象。本规范中定义的 ECMAScript 并不打算是计算自给自足的;实际上,本规范没有规定外部数据的输入或计算结果的输出。相反,预计 ECMAScript 程序的计算环境不仅会提供本规范中描述的对象和其他设施,还会提供某些环境特定的对象,这些对象的描述和行为超出了本规范的范围,只是表明它们可能提供某些属性可以从 ECMAScript 程序中访问和调用的函数。
ECMAScript 最初设计为一种脚本语言,但现已广泛用作通用编程语言。脚本语言 是一种用于操作、定制和自动化现有系统功能的编程语言。在这些系统中,有用的功能已经通过用户界面可用,脚本语言是将这些功能暴露给程序控制的机制。这样,现有系统就提供了一个对象和设施的 宿主环境,从而完善了脚本语言的功能。脚本语言旨在供专业和非专业程序员使用。
ECMAScript 最初设计为一种 Web 脚本语言,提供一种机制来在浏览器中使网页生动起来,并作为基于 Web 的客户端-服务器架构的一部分执行服务器计算。ECMAScript 现在用于为各种 宿主环境 提供核心脚本功能。因此,本文件中规定的核心语言与任何特定的 宿主环境 无关。
ECMAScript 的使用已经超出了简单的脚本编写,它现在用于许多不同环境和规模的全方位编程任务。随着 ECMAScript 使用范围的扩大,它提供的功能和设施也在扩展。ECMAScript 现在是一种功能齐全的通用编程语言。
Web浏览器为客户端计算提供了一个ECMAScript 宿主环境,包括表示窗口、菜单、弹出窗口、对话框、文本区域、锚点、框架、历史记录、Cookies以及输入/输出的对象。此外,宿主环境还提供了一种将脚本代码附加到事件(如焦点更改、页面和图像加载、卸载、错误和中止、选择、表单提交和鼠标操作)的方法。脚本代码出现在HTML中,显示的页面是用户界面元素和固定和计算文本及图像的组合。脚本代码对用户交互有反应,因此不需要主程序。
Web服务器为服务器端计算提供了不同的宿主环境,包括表示请求、客户端和文件的对象;以及锁定和共享数据的机制。通过结合使用浏览器端和服务器端脚本,可以在客户端和服务器之间分配计算,同时为基于Web的应用程序提供定制的用户界面。
每个支持ECMAScript的Web浏览器和服务器都提供自己的宿主环境,从而完成ECMAScript的执行环境。
为了帮助将ECMAScript集成到宿主环境中,本规范将某些功能的定义(例如,抽象操作)全部或部分地推迟到本规范之外的来源。在编辑上,本规范区分了以下几种推迟定义的方式。
实现是进一步定义附录D中列出的功能或那些标记为实现定义或实现近似的功能的外部来源。在非正式使用中,实现是指具体的人工制品,例如特定的网络浏览器。
实现定义的功能是指将其定义推迟到外部来源而没有进一步的限定。本规范对特定行为没有做出任何建议,符合规范的实现可以在本规范提出的约束范围内选择任何行为。
实现近似的功能是指将其定义推迟到外部来源,同时建议一种理想行为。虽然符合规范的实现可以在本规范提出的约束范围内选择任何行为,但鼓励它们尽量接近理想。一些数学操作,例如Math.exp,属于实现近似。
宿主是进一步定义附录D中列出的功能,但不进一步定义其他实现定义或实现近似功能的外部来源。在非正式使用中,宿主是指以相同方式通过附录D与本规范接口的所有实现集,例如所有网络浏览器的集合。宿主通常是一个外部规范,例如WHATWG HTML (https://html.spec.whatwg.org/)。换句话说,宿主定义的功能通常在外部规范中进一步定义。
宿主挂钩 是一个由外部来源全部或部分定义的抽象操作。所有 宿主挂钩 必须列在附录 D 中。宿主挂钩 必须至少符合以下要求:
宿主定义 的功能是将其定义推迟到外部来源而没有进一步的限定,并列在附录 D 中。不是 宿主 的实现也可以提供 宿主定义 的功能定义。
宿主环境 是所有 宿主定义 功能的特定定义选择。宿主环境 通常包括允许获取输入和提供输出的对象或函数,作为 宿主定义 属性的一部分的 全局对象。
本规范遵循始终使用最具体术语的编辑约定。例如,如果一个功能是 宿主定义 的,则不应称其为 实现定义。
宿主和实现可以通过本规范中定义的语言类型、规范类型、抽象操作、语法生成、内在对象和内在符号与本规范接口。
以下是 ECMAScript 的非规范性概述,并未描述该语言的所有部分。该概述不属于标准的正式部分。
ECMAScript 是基于对象的:基本语言和宿主功能由对象提供,ECMAScript
程序是一个相互通信的对象集合。在 ECMAScript 中,对象 是具有零个或多个 属性 的集合,每个属性都有确定如何使用该属性的 特性 ——
例如,当属性的可写特性(Writable attribute)设置为
ECMAScript 定义了一组 内置对象,完善了 ECMAScript 实体的定义。这些内置对象包括 全局对象;对语言的 运行时语义 基本的对象,包括
Object、Function、Boolean、Symbol 及各种 Error
对象;表示和操作数值的对象,包括 Math、Number 和 Date;处理文本的对象 String 和
RegExp;值的索引集合的对象,包括 Array 和九种不同类型的元素具有特定数值表示的 Typed Arrays;键控集合,包括 Map
和 Set 对象;支持结构化数据的对象,包括 JSON
对象、ArrayBuffer、SharedArrayBuffer 和 DataView;支持控制抽象的对象,包括生成器函数和
Promise 对象;以及反射对象,包括 Proxy 和 Reflect。
ECMAScript 还定义了一组内置 运算符。ECMAScript 运算符包括各种一元运算符、乘法运算符、加法运算符、位移运算符、关系运算符、相等运算符、二进制位运算符、二进制逻辑运算符、赋值运算符和逗号运算符。
大型 ECMAScript 程序由 模块 支持,允许程序划分为多个语句和声明的序列。每个模块明确标识其使用的需要由其他模块提供的声明,以及哪些声明可供其他模块使用。
ECMAScript 语法故意类似于 Java 语法。ECMAScript 语法被放宽,以使其作为一种易于使用的脚本语言。例如,变量不需要声明其类型,属性也没有关联类型,定义的函数也不需要在调用之前出现在文本上。
尽管 ECMAScript 包含类定义的语法,但 ECMAScript 对象并非如 C++、Smalltalk 或 Java 中的类为基础。相反,对象可以通过多种方式创建,包括字面量表示法或 构造函数,这些构造函数创建对象,然后通过为其属性分配初始值来初始化全部或部分对象。每个 构造函数 都是一个具有名为
new Date(2009, 11)
创建一个新的 Date 对象。不使用 new 调用 构造函数
会产生不同的结果,这取决于 构造函数。例如,Date()
生成当前日期和时间的字符串表示,而不是对象。
每个由 构造函数 创建的对象都有一个隐式引用(称为对象的
原型),指向其 构造函数 的
在基于类的面向对象语言中,通常状态由实例承载,方法由类承载,并且继承仅限于结构和行为。而在 ECMAScript 中,状态和方法由对象承载,而结构、行为和状态都是继承的。
所有不直接包含其原型所包含的特定属性的对象共享该属性及其值。图 1 说明了这一点:
CF 是一个 构造函数(也是一个对象)。通过使用
new
表达式创建了五个对象:cf1、cf2、cf3、cf4 和
cf5。这些对象每个都包含名为
与大多数基于类的对象语言不同,可以通过分配值动态地向对象添加属性。也就是说,构造函数 不需要命名或分配所有或任何构造对象的属性。在上图中,可以通过向 CFp 中的属性分配新值,为 cf1、cf2、cf3、cf4 和 cf5 添加一个新的共享属性。
尽管 ECMAScript 对象本质上不是基于类的,但根据 构造函数、原型对象和方法的共同模式定义类样抽象通常是方便的。ECMAScript 内置对象本身遵循这样的类样模式。从 ECMAScript 2015 开始,ECMAScript 语言包括语法类定义,允许程序员简洁地定义符合内置对象使用的相同类样抽象模式的对象。
ECMAScript 语言认识到某些用户可能希望限制其使用语言中某些功能的可能性。他们可能出于安全考虑,避免他们认为容易出错的功能,获得增强的错误检查,或出于其他原因。为了支持这种可能性,ECMAScript 定义了语言的严格变体。语言的严格变体排除了一些常规 ECMAScript 语言的特定语法和语义特性,并修改了某些特性的详细语义。严格变体还指定了在非严格形式的语言未指定为错误的情况下必须通过抛出错误异常来报告的其他错误条件。
ECMAScript 的严格变体通常称为语言的严格模式。严格模式的选择和 ECMAScript 严格模式语法和语义的使用明确在单个 ECMAScript 源文本 单元级别进行,如 11.2.2 中所述。由于在语法源文本单元级别选择严格模式,因此严格模式仅对该源文本单元内具有局部效果的限制。严格模式不会限制或修改必须在多个源文本单元之间一致操作的 ECMAScript 语义。完整的 ECMAScript 程序可以由严格模式和非严格模式 ECMAScript 源文本 单元组成。在这种情况下,严格模式仅在实际执行在严格模式源文本单元中定义的代码时才适用。
为了符合本规范,ECMAScript 实现必须实现完整的无限制 ECMAScript 语言和本规范定义的 ECMAScript 语言的严格变体。此外,实现必须支持将无限制和严格模式源文本单元组合成一个单一的组合程序。
在本文件中,适用以下术语和定义。
一个 实现近似 设施是由外部来源全部或部分定义的,但在本规范中有推荐的理想行为。
一个 实现定义 设施是由外部来源全部或部分定义的。
与 实现定义 相同。
编辑说明,参见 4.2 条款。
数据值集合,定义见
是 Undefined、Null、Boolean、Number、BigInt、Symbol 或 String 类型中的一个成员,定义见
原始值是在语言实现的最低层直接表示的数据。
Object 类型的成员。
对象是属性的集合,并且有一个单一的原型对象。原型可以是
构造函数的
为其他对象提供共享属性的对象。
具有所有对象必须支持的基本内部方法默认行为的对象
在一个或多个基本内部方法上不具有默认行为的对象
其语义由本规范定义的对象
由 ECMAScript 实现指定和提供的对象
标准内置对象在本规范中定义。ECMAScript 实现可以指定和提供其他种类的内置对象。
当变量未被赋值时使用的原始值
唯一值为
表示故意缺少任何对象值的原始值
唯一值为
属于
只有两个布尔值,
由原始值
属于
Boolean 对象是通过在 new 表达式中使用 Boolean
原始值,是一个
所有可能的字符串值的集合
对应双精度 64 位二进制格式
Number 值是
所有可能的 Number 值的集合,包括特殊的“非数值” (NaN) 值、正无穷大和负无穷大
属于
表示正无穷大的 Number 值
表示
对应任意精度
所有可能的 BigInt 值的集合
表示唯一的、非字符串对象
所有可能的 Symbol 值的集合
属于
除了它的属性之外,函数还包含可执行代码和状态,这些代码和状态决定了它在调用时的行为。函数的代码可以是 ECMAScript 编写的,也可以不是。
内置对象,是一个函数
内置函数的例子包括 parseInt 和 Math.exp。
内置函数,是一个
对象的一部分,关联一个键(字符串值或 Symbol 值)和一个值
根据属性的形式,值可以直接表示为数据值(原始值、对象或
作为属性值的函数
当函数作为对象的方法调用时,对象会作为其
作为内置函数的方法
标准内置方法在本规范中定义。
定义属性某些特性的内部值
直接包含在对象中的属性
对象的属性,不是自有属性,但它是对象原型的属性(自有属性或继承属性)
本规范的其余部分组织如下:
第
第
第
第
第
一个上下文无关文法由若干生成式组成。每个生成式的左侧都有一个抽象符号,称为非终结符,右侧则是一系列零个或多个非终结符和终结符符号。对于每个文法,终结符号来自指定的字母表。
链生成式是右侧有且只有一个非终结符号以及零个或多个终结符号的生成式。
从一个由单个特殊非终结符组成的句子开始,称为目标符号,给定的上下文无关文法指定了一种语言,即通过不断将序列中的任何非终结符替换为其左侧为该非终结符的生成式的右侧所能产生的终结符号的(可能是无限的)集合。
ECMAScript 的词法文法在
除空白和注释外的输入元素构成 ECMAScript 语法文法的终结符,称为 ECMAScript 标记。这些标记是 ECMAScript 语言的 /*…*/ 的注释,不论是否跨越多行)不包含行终止符,则它同样会被丢弃;但如果
ECMAScript 的正则表达式文法在
词法和正则表达式文法的生成式通过两个冒号 “::” 作为分隔标点来区分。这两种文法共享一些生成式。
在
数值字符串文法的生成式通过三个冒号 “:::” 作为标点符号来区分,且从不用于解析源文本。
ECMAScript 的 句法文法 在
当要将代码点流解析为 ECMAScript
解析成功时,会构造一个 解析树,这是一个以根为起点的树结构,其中每个节点是一个 解析节点。每个解析节点都是文法中某个符号的实例;它表示可以从该符号派生的源文本范围。表示整个源文本的解析树的根节点是解析的
解析器的每次调用都会实例化新的解析节点,并且在解析相同源文本时永不重用。解析节点被认为是相同的解析节点,当且仅当它们表示相同的源文本范围,是相同文法符号的实例,并且是由同一次解析器调用生成的。
多次解析相同的字符串会导致不同的解析节点。例如,考虑:
let str = "1 + 1;";
eval(str);
eval(str);
每次调用 eval 都会将 str 的值转换为
句法文法的生成式通过使用一个冒号 “:” 作为标点符号来区分。
在
在某些情况下,为避免歧义,句法文法使用了泛化生成式,允许不形成有效 ECMAScript
在ECMAScript语法中,一些终结符号显示为固定宽度字体。这些符号应当按照书写的样子准确出现在源文本中。以这种方式指定的所有终结符号码点都应被理解为来自基本拉丁块的适当Unicode码点,而不是来自其他Unicode范围的类似看起来的码点。终结符号中的一个码点不能通过\
在其终结符号是单个Unicode码点的语法中(即,词汇、RegExp和数值字符串语法),连续的多个固定宽度码点出现在一个生产中,是一种简单的速记,用于表示相同的码点序列,写作独立的终结符号。
例如,产生式:
是以下的简写形式:
相比之下,在句法语法中,连续的固定宽度码点构成一个单独的终结符号。
终结符号还有其他两种形式:
非终结符号显示为斜体类型。非终结(也称为“产生式”)的定义是由被定义的非终结名称开始,后面跟着一个或多个冒号(冒号的数量表示生产所属的语法)。然后,非终结的一个或多个备选右侧在后续行中跟随。例如,句法定义:
说明非终结while,后跟一个左括号,然后是一个
说明一个
下标后缀“opt”,可出现在终结符或非终结符之后,表示一个可选符号。包含可选符号的替代项实际上指定了两个右侧,一个省略可选元素,一个包含它。这意味着:
是一个方便的缩写:
和:
是一个方便的缩写:
反过来又是一个缩写:
因此,在这个例子中,非终结符
一个产生式可能会被形式为“[parameters]”的下标注释参数化,它可能作为由产生式定义的非终结符号的后缀出现。“parameters”可以是单个名称或逗号分隔的名称列表。参数化的产生式是一组产生式的简写,这些产生式定义了所有参数名称的组合,这些名称由下划线前缀,并附加到参数化的非终结符号上。这意味着:
是以下的缩写:
并且:
是以下的缩写:
多个参数会产生组合数量的产生式,但并不是所有的产生式都必须在完整的语法中被引用。
产生式右侧的非终结符号的引用也可以被参数化。例如:
等同于说:
以及:
相当于:
一个非终结符的引用可能同时具有参数列表和“opt”后缀。例如:
是以下的缩写:
在右侧非终结符引用中,用“?”前缀参数名称,使得该参数值依赖于当前产生式左侧符号引用中参数名称的出现。例如:
是以下的缩写:
如果右侧的备选方案以“[+parameter]”为前缀,那么这个备选方案只在引用产生式的非终结符号时使用了指定的参数才可用。如果右侧的备选方案以“[~parameter]”为前缀,那么这个备选方案只在引用产生式的非终结符号时未使用指定的参数才可用。这意味着:
是以下的缩写:
并且:
是以下的缩写:
当语法定义中的冒号后面跟着“one of”这几个词时,它们表示接下来的每一行上的终结符号都是一个替代定义。例如,ECMAScript的词法语法包含以下产生式:
这只是一个方便的缩写,完整形式为:
如果产生式的右侧出现“[empty]”这一短语,它表示该产生式的右侧不包含任何终结符号或非终结符号。
如果短语“[lookahead = seq]”出现在产生式的右侧,它表示只有当令牌序列seq是紧随其后的输入令牌序列的前缀时,才能使用该产生式。类似地,“[lookahead ∈ set]”,其中set是一个非空的有限令牌序列集合,表示只有当set中的某个元素是紧随其后的令牌序列的前缀时,才能使用该产生式。为了方便起见,该集合也可以写作非终结符,这种情况下它代表所有非终结符可以扩展到的令牌序列的集合。如果非终结符可以扩展到无限多个不同的令牌序列,则被认为是编辑错误。
这些条件可以被否定。“[lookahead ≠ seq]”表示只有当seq不是紧随其后的输入令牌序列的前缀时,才能使用包含的产生式,“[lookahead ∉ set]”表示只有当set中的没有元素是紧随其后的令牌序列的前缀时,才能使用该产生式。
例如,给定以下定义:
定义如下:
匹配字母n,后跟一个或多个十进制数字,第一个数字为偶数,或一个十进制数字,后面没有跟随另一个十进制数字。
注意,当这些短语在句法语法中使用时,可能无法明确识别紧随其后的令牌序列,因为确定后续的令牌需要知道在后续位置使用哪个词法目标符号。因此,当这些短语在句法语法中使用时,如果词法目标符号的选择可能会改变seq是否会成为生成的令牌序列的前缀,那么在前视限制中出现令牌序列seq(包括作为序列集合的一部分)被认为是编辑错误。
如果在句法文法的生成式右侧出现短语“[no
表示如果在脚本中 throw 标记和
除非受限生成式禁止出现
生成式的右侧可以使用短语“but not”并指示要排除的扩展来指定不允许某些扩展。例如,生成式:
意味着非终结符
最后,在一些列出所有替代方案不切实际的情况下,使用无衬线字体的描述性短语来描述少数非终结符号:
该规范经常使用编号列表来指定算法中的步骤。这些算法用于精确指定 ECMAScript 语言结构的所需语义。这些算法并不意味着必须使用任何特定的实现技术。实际上,可能有更有效的算法可用于实现给定的功能。
算法可以明确地用一个有序的、逗号分隔的别名序列参数化,这些别名在算法步骤中可用于引用在该位置传入的参数。可选参数用方括号([ , name
])表示,与算法步骤中的必需参数没有区别。参数列表的末尾可以出现一个剩余参数,以省略号(, ...name)表示。剩余参数捕获所有在必需参数和可选参数之后提供的参数,这些参数被编入一个
算法步骤可以细分为顺序子步骤。子步骤是缩进的,并且本身可以进一步分为缩进的子步骤。用大纲编号约定来标识子步骤,第一层子步骤用小写字母标记,第二层子步骤用小写罗马数字标记。如果需要超过三个层级,这些规则将重复,第四层使用数字标签。例如:
步骤或子步骤可以作为一个“if”谓词编写,条件化其子步骤。在这种情况下,只有当谓词为真时,子步骤才会被应用。如果步骤或子步骤以“else”一词开头,它是一个谓词,是与同一层级前一个“if”谓词步骤的否定。
步骤可以指定其子步骤的迭代应用。
以“Assert(断言):”开头的步骤断言其算法的不变条件。这种断言用来明确那些否则会是隐含的算法不变性。这样的断言不增加额外的语义要求,因此实现无需检查。它们仅用于澄清算法。
算法步骤可以使用“Let x be someValue”的形式声明任何值的命名别名。这些别名类似于引用,x和someValue都指向相同的底层数据,对任何一个的修改都对双方可见。如果算法步骤想要避免这种类似引用的行为,应该明确地复制右侧值:“Let x be a copy of someValue”创建了someValue的一个浅拷贝。
一旦声明,别名可以在任何后续步骤中被引用,并且不能从别名声明之前的步骤中被引用。别名可以使用“Set x to someOtherValue”的形式进行修改。
为了便于在本规范的多个部分中使用,一些算法被称为抽象操作,它们被命名并以参数化的函数形式编写,以便可以从其他算法中通过名称引用它们。抽象操作通常使用函数应用风格引用,如 OperationName(arg1, arg2)。一些抽象操作被视为类似类的规范抽象中多态分派的方法。这种类似方法的抽象操作通常使用方法应用风格引用,例如 someValue.OperationName(arg1, arg2)。
一个语法指导操作是一个命名操作,其定义包括多个算法,每个算法都与ECMAScript语法之一的一个或多个产生式相关联。具有多个替代定义的产生式通常会为每个替代定义有一个独特的算法。当一个算法与一个语法产生式相关联时,它可以引用产生式替代的终结符和非终结符,就好像它们是算法的参数一样。在这种方式下使用时,非终结符引用在解析源文本时匹配的实际替代定义。由语法产生式匹配的源文本或由其衍生的
当一个算法与一个产生式替代相关联时,该替代通常显示时不包括任何“[ ]”语法注释。这样的注释只应影响替代的语法识别,对替代的相关语义没有影响。
语法指导操作通过使用下列算法中的步骤
除非另有明确规定,所有
但是
运行时语义:
需要在运行时调用以指定语义的算法称为运行时语义。运行时语义由
抽象操作完成接受参数completionRecord(一个
算法步骤中提到抛出异常的,如:
意味着与以下内容相同:
算法步骤中提到或等同于以下内容:
意味着:
算法步骤中提到或等同于:
意味着:
hygienicTemp 是短暂的,仅在涉及 ReturnIfAbrupt 的步骤中可见。
算法步骤中提到或等同于:
意味着:
在?表示应当应用
等同于以下步骤:
同样,对于方法应用风格,步骤:
等同于:
同样地,前缀!用来表示以下对抽象或
等同于以下步骤:
!或?:
在声明返回
如果通过任何其他方式从这样的抽象操作中返回
意味着与任何一种
或
或
注意,通过
以下示例将是一个编辑错误,因为在该步骤中没有注明正在返回
无上下文语法并不足以表达所有定义流式输入元素是否形成可评估的 ECMAScript
静态语义规则具有名称,并通常使用算法定义。命名的静态语义规则与语法产生式相关联,具有多个备选定义的产生式通常对每个适用的命名静态语义规则有一个单独的算法。
静态语义规则的一种特殊类型是早期错误规则。
本规范参考以下数值类型:
在本规范的术语中,数值使用下标后缀来区分不同的数值类型。下标 𝔽 表示数字(Numbers),下标 ℤ 表示大整数(BigInts)。没有下标后缀的数值指代
数值运算符(如 +、×、= 和 ≥)根据操作数的类型确定其操作。当应用于
一般来说,当本规范提到数值时,例如“y 的长度”或“由四位十六进制数字表示的
不定义混合类型操作数(例如数字和
本规范中大多数数值以十进制表示;同时也使用形如 0x 后跟数字 0-9 或 A-F 的十六进制值。
当本规范中使用术语 整数 时,指的是在
本文档中对
数学函数
数学函数
记法 “
短语 "将 x 夹在 lower 和 upper 之间"(其中 x 是
数学函数
数学函数
数学函数
从下界 a 到上界 b 的 区间 是可能是无限的、可能为空的、相同数值类型的数值集合。每个边界都将描述为包含或排除,但不会同时包含。有四种类型的区间,如下所示:
例如,从 1(包含)到 2(排除)的
在本规范中,Function.prototype.apply 或 let n = 42; 区分开来。
在本规范中,规范值和
从本规范的角度来看,“is”一词用于比较两个值是否相等,例如“如果bool为
从 ECMAScript 语言的角度来看,语言值使用
对于规范值,没有规范身份的值包括但不限于:
规范身份对于所有
本规范中的算法操作值,每个值都有一个关联的类型。可能的值类型正是本条款中定义的那些类型。类型进一步分为
在本规范中,“Type(x)”表示“x的类型”,其中“类型”指的是本条款中定义的ECMAScript语言和规范类型。
ECMAScript 语言类型对应于由 ECMAScript 程序员直接使用 ECMAScript 语言操作的值。ECMAScript 语言类型包括 Undefined、Null、Boolean、String、Symbol、Number、BigInt 和 Object。一个ECMAScript 语言值是由 ECMAScript 语言类型特征化的值。
Undefined 类型恰好有一个值,称为
Null 类型恰好有一个值,称为
Boolean 类型表示具有两个值的逻辑实体,称为
String 类型是所有有序序列的集合,这些序列由零个或多个 16
位无符号
不解释 String 内容的 ECMAScript 操作不应用进一步的语义。对解释 String 值的操作将每个元素视为单个 UTF-16 代码单元。然而,ECMAScript 不限制这些代码单元的值或关系,因此进一步解释 String 内容为 UTF-16 编码的 Unicode 代码点序列的操作必须考虑到格式不正确的子序列。这些操作对于每个数值位于从 0xD800 到 0xDBFF(由 Unicode 标准定义为leading surrogate,或更正式地称为high-surrogate code unit)的代码单元,以及每个数值位于从 0xDC00 到 0xDFFF(定义为trailing surrogate,或更正式地称为low-surrogate code unit)的代码单元使用以下规则:
函数 String.prototype.normalize(参见22.1.3.15)可以用来显式标准化一个字符串值。String.prototype.localeCompare(参见22.1.3.12)在内部标准化字符串值,但其他操作不会隐式地标准化它们操作的字符串。操作结果除非另有说明,否则不受语言和/或地区的影响。
这种设计背后的理念是为了保持字符串的实现尽可能简单和高效。如果ECMAScript源代码文本处于规范形式C,只要它们不包含任何Unicode转义序列,字符串字面值也保证是标准化的。
在这个规范中,“字符串连接 A、B 等...”(每个参数是一个字符串值、代码单元或代码单元的序列)表示的是一个字符串值,其代码单元的序列是每个参数(按顺序)的代码单元的连接(按顺序)。
短语“从 inclusiveStart 到 exclusiveEnd 的 子字符串”(其中 S 是一个字符串值或代码单元序列,而 inclusiveStart 和 exclusiveEnd 是整数)表示由 S 的连续代码单元组成的字符串值,开始于索引 inclusiveStart 并在索引 exclusiveEnd 之前立即结束(当 inclusiveStart = exclusiveEnd 时为空字符串)。如果省略了“to”后缀,则使用 S 的长度作为 exclusiveEnd 的值。
短语“ASCII 单词字符”表示以下字符串值,它仅由 Unicode 基本拉丁语块中的每个字母和数字以及
U+005F(下划线)组成:
出于历史原因,它对各种算法具有重要意义。
抽象操作 StringIndexOf 接受参数 string(一个字符串)、searchValue(一个字符串)和 fromIndex
(一个非负
如果 searchValue 是空字符串且 fromIndex ≤ string 的长度,该算法返回 fromIndex。空字符串实际上在字符串中的每个位置都能找到,包括在最后一个码位之后。
如果 fromIndex 加上 searchValue 的长度大于 string 的长度,该算法总是返回 -1。
符号类型 是可以用作对象属性键的所有非字符串值的集合(
每个可能的符号值都是唯一且不可变的。
每个符号值不可变地持有一个关联的值,称为 [[Description]],它要么是
众所周知的符号是本规范算法明确引用的内建符号值。它们通常用作属性的键,这些属性的值作为规范算法的扩展点。除非另有说明,否则众所周知的符号值在所有
在本规范中,一个众所周知的符号用 @@name 的形式表示,其中“name”是
| 规范名称 | [[Description]] | 值和用途 |
|---|---|---|
| @@asyncIterator |
|
一个方法,返回对象的默认异步迭代器。由for-await-of语句的语义调用。
|
| @@hasInstance |
|
一个方法,确定构造函数对象是否将某个对象识别为其实例之一。由instanceof运算符的语义调用。
|
| @@isConcatSpreadable |
|
一个布尔值属性,如果为true,表示对象应通过Array.prototype.concat |
| @@iterator |
|
一个方法,返回对象的默认迭代器。由for-of语句的语义调用。 |
| @@match |
|
一个正则表达式方法,将正则表达式与字符串匹配。由String.prototype.match |
| @@matchAll |
|
一个正则表达式方法,返回一个迭代器,该迭代器生成正则表达式与字符串匹配的所有结果。由String.prototype.matchAll |
| @@replace |
|
一个正则表达式方法,替换字符串中的匹配子字符串。由String.prototype.replace |
| @@search |
|
一个正则表达式方法,返回匹配正则表达式的字符串中的索引。由String.prototype.search |
| @@species |
|
一个函数值属性,是用于创建派生对象的构造函数。 |
| @@split |
|
一个正则表达式方法,在匹配正则表达式的索引处分割字符串。由String.prototype.split |
| @@toPrimitive |
|
一个方法,将对象转换为相应的原始值。由 |
| @@toStringTag |
|
一个字符串值属性,用于创建对象的默认字符串描述。由内建方法Object.prototype.toString |
| @@unscopables |
|
一个对象值属性,其自身和继承的属性名称是从相关对象的with环境绑定中排除的属性名称。
|
ECMAScript 有两种内建的数字类型:Number 和 BigInt。以下
由于数值类型通常不能在不损失精度或截断的情况下相互转换,ECMAScript语言不提供这些类型之间的隐式转换。在调用需要另一种类型的函数时,程序员必须显式调用 Number 和
BigInt 函数进行类型转换。
ECMAScript 的早期和后续版本为某些运算符提供了隐式数值转换,这可能会损失精度或
数字类型(Number type)具有精确的
18,437,736,874,454,810,627
(即 NaN 产生。)在一些实现中,外部代码可能能够检测到各种不同的非数值,但这种行为是
还有另外两个特殊值,分别称为 +Infinity(或简单地
Infinity)和 -Infinity 产生。)
其余的 18,437,736,874,454,810,624(即
注意,这里有一个 +0(或简单地 0)和 -0 产生。)
18,437,736,874,454,810,622(即
18,428,729,675,200,069,632(即
其中,s 可以是 1 或 -1,m 是一个
剩余的 9,007,199,254,740,990(即
其中,s 可以是 1 或 -1,m 是一个
注意,在 Number 类型中,所有不大于 253 的正整数和负整数都可以表示。整数 0 在 Number
类型中有两种表示形式:
一个
一些 ECMAScript 运算符只处理特定范围内的
抽象操作 Number::unaryMinus 接受参数 x(一个 Number),并返回一个 Number。调用时执行以下步骤:
抽象操作 Number::bitwiseNOT 接受参数 x(一个 Number),并返回一个
抽象操作 Number::exponentiate 接受参数 base(一个 Number)和 exponent(一个 Number),并返回一个
Number。它返回一个
当 base 是 ** exponent 的结果与
抽象操作 Number::multiply 接受参数 x(一个 Number)和 y(一个 Number),返回一个 Number。它根据
抽象操作 Number::divide 接受参数 x(一个 Number)和 y(一个 Number),返回一个 Number。
它根据
抽象操作 Number::remainder 接受参数 n(一个 Number)和 d(一个 Number),返回一个 Number。 它返回其操作数的隐含除法的余数,其中 n 是被除数,d 是除数。调用时执行以下步骤:
在 C 和 C++ 中,取余运算符只接受整数操作数;在 ECMAScript 中,它也接受浮点操作数。
% 运算符计算的“余数”操作不同,后者由 % 以类似于 Java 抽象操作 Number::add 接受参数 x(一个 Number)和 y(一个 Number),返回一个
Number。它根据
抽象操作 Number::subtract 接受参数 x(一个 Number)和 y(一个 Number),返回一个 Number。它执行减法运算,生成其操作数的差;x 是被减数,y 是减数。调用时执行以下步骤:
总是有 x - y 的结果与 x + (-y) 相同。
抽象操作 Number::leftShift 接受参数 x(一个 Number)和 y(一个 Number),返回一个整数 Number。调用时执行以下步骤:
抽象操作 Number::signedRightShift 接受参数 x(一个 Number)和 y(一个 Number),返回一个整数 Number。调用时执行以下步骤:
抽象操作 Number::unsignedRightShift 接受参数 x(一个 Number)和 y(一个 Number),返回一个整数 Number。调用时执行以下步骤:
抽象操作 Number::lessThan 接受参数 x(一个 Number)和 y(一个 Number),返回一个布尔值或
抽象操作 Number::equal 接受参数 x(一个 Number)和 y(一个 Number),返回一个布尔值。调用时执行以下步骤:
抽象操作 Number::sameValue 接受参数 x(一个 Number)和 y(一个 Number),返回一个布尔值。调用时执行以下步骤:
抽象操作 Number::sameValueZero 接受参数 x(一个 Number)和 y(一个 Number),返回一个布尔值。调用时执行以下步骤:
抽象操作 Number::NumberBitwiseOp 接受参数 op(&、^ 或
|)、x(一个 Number)和 y(一个 Number),返回一个
&,则^,则|。
抽象操作 Number::bitwiseAND 接受参数 x(一个 Number)和 y(一个 Number),返回一个
&,
x, y).
抽象操作 Number::bitwiseXOR 接受参数 x(一个 Number)和 y(一个 Number),返回一个
^,
x, y).
抽象操作 Number::bitwiseOR 接受参数 x(一个 Number)和 y(一个 Number),返回一个
|,
x, y).
抽象操作 Number::toString 接受参数 x(一个数字)和 radix(一个在 2 到 36 之间的整数),并返回一个字符串。它使用以
radix 为基数的进位制系统将 x 表示为字符串。使用基数 r 表示数字时所用的数字取自
1.2e+3。
ECMAScript 的实现者可能会发现 David M. Gay 撰写的关于浮点数二进制到十进制转换的论文和代码很有用:
Gay, David M. 正确舍入的二进制-十进制和十进制-二进制转换。数值分析,手稿 90-10。AT&T 贝尔实验室(新泽西州默里山)。1990 年 11 月 30 日。
可在
http://ampl.com/REFS/abstracts.html#rounding
获取。
相关代码可在
http://netlib.sandia.gov/fp/dtoa.c 和
http://netlib.sandia.gov/fp/g_fmt.c 获取,并且可能在各个
netlib 镜像站点上找到。
BigInt 类型 表示一个
抽象操作 BigInt::unaryMinus 接受参数 x(一个 BigInt)并返回一个 BigInt。它在被调用时执行以下步骤:
抽象操作 BigInt::bitwiseNOT 接受参数 x(一个 BigInt)并返回一个 BigInt。 它返回 x 的按位取反。它在被调用时执行以下步骤:
抽象操作 BigInt::exponentiate 接受参数 base(一个 BigInt)和 exponent(一个 BigInt),并返回一个包含 BigInt 的正常完成或抛出完成。它在被调用时执行以下步骤:
抽象操作 BigInt::multiply 接受参数 x(一个 BigInt)和 y(一个 BigInt)并返回一个 BigInt。它在被调用时执行以下步骤:
抽象操作 BigInt::divide 接受参数 x(一个 BigInt)和 y(一个 BigInt),并返回一个包含 BigInt 的正常完成或抛出完成。它在被调用时执行以下步骤:
抽象操作 BigInt::remainder 接受参数 n(一个 BigInt)和 d(一个 BigInt),并返回一个
抽象操作 BigInt::add 接受参数 x(一个 BigInt)和 y(一个 BigInt)并返回一个 BigInt。它在被调用时执行以下步骤:
抽象操作 BigInt::subtract 接受参数 x(一个 BigInt)和 y(一个 BigInt)并返回一个 BigInt。它在被调用时执行以下步骤:
抽象操作 BigInt::leftShift 接受参数 x(一个 BigInt)和 y(一个 BigInt)并返回一个 BigInt。它在被调用时执行以下步骤:
抽象操作 BigInt::signedRightShift 接受参数 x(一个 BigInt)和 y(一个 BigInt)并返回一个 BigInt。它在被调用时执行以下步骤:
抽象操作 BigInt::unsignedRightShift 接受参数 x(一个 BigInt)和 y(一个 BigInt)并返回一个
抽象操作 BigInt::lessThan 接受参数 x(一个 BigInt)和 y(一个 BigInt)并返回一个布尔值。它在被调用时执行以下步骤:
抽象操作 BigInt::equal 接受参数 x(一个 BigInt)和 y(一个 BigInt)并返回一个布尔值。它在被调用时执行以下步骤:
抽象操作 BinaryAnd 接受参数 x(0 或 1)和 y(0 或 1)并返回 0 或 1。它在被调用时执行以下步骤:
抽象操作 BinaryOr 接受参数 x(0 或 1)和 y(0 或 1)并返回 0 或 1。它在被调用时执行以下步骤:
抽象操作 BinaryXor 接受参数 x(0 或 1)和 y(0 或 1)并返回 0 或 1。它在被调用时执行以下步骤:
抽象操作 BigInt位运算 接受参数 op(&、
^ 或 |)、x(一个 BigInt)和 y(一个 BigInt)并返回一个
BigInt。它在被调用时执行以下步骤:
&,那么
|,那么
抽象操作 BigInt::bitwiseAND 接受参数 x(一个 BigInt)和 y(一个 BigInt)并返回一个 BigInt。它在调用时执行以下步骤:
&,
x, y)。
抽象操作 BigInt::bitwiseXOR 接受参数 x(一个 BigInt)和 y(一个 BigInt)并返回一个 BigInt。它在调用时执行以下步骤:
^,
x, y)。
抽象操作 BigInt::bitwiseOR 接受参数 x(一个 BigInt)和 y(一个 BigInt)并返回一个 BigInt。它在调用时执行以下步骤:
|,
x, y)。
抽象操作 BigInt::toString 接受参数 x(一个 BigInt)和 radix(一个在 2 到 36 之间的整数)并返回一个字符串。它使用基数
radix 将 x 表示为字符串。使用基数 r 表示 BigInt 的数字取自
每个 对象类型 的实例,也简称为“一个对象”,表示一个属性的集合。每个属性要么是一个数据属性,要么是一个访问器属性:
对象的属性使用属性键唯一标识。一个 属性键
要么是一个字符串,要么是一个符号。所有字符串和符号,包括空字符串,都可以作为属性键。一个 属性名 是一个
一个 整数索引 是一个
属性键用于访问属性和它们的值。属性访问有两种类型:获取 和 设置,分别对应于值的检索和赋值。通过获取和设置访问的属性包括 自有属性 和 继承属性。继承属性可能是关联对象的自有属性或继承属性。每个对象的自有属性必须具有与其他自有属性不同的键值。
所有对象在逻辑上都是属性的集合,但有多种形式的对象,它们的属性访问和操作语义不同。请参见
此外,一些对象是可调用的;这些被称为函数或
属性用于在本规范中定义和解释对象属性的状态,如
| 属性名称 | 存在的属性类型 | 值域 | 默认值 | 描述 |
|---|---|---|---|---|
| [[Value]] |
|
|
|
通过获取属性访问检索到的值。 |
| [[Writable]] |
|
布尔值 |
|
如果为 |
| [[Get]] |
|
对象或 |
|
如果值 |
| [[Set]] |
|
对象或 |
|
如果值 |
| [[Enumerable]] |
|
一个布尔值 |
|
如果 |
| [[Configurable]] |
|
一个布尔值 |
|
如果 |
在 ECMAScript 中,对象的实际语义是通过称为 内部方法 的算法指定的。每个 ECMAScript 引擎中的对象都与一组内部方法相关联,这些方法定义了其运行时行为。这些内部方法不是 ECMAScript 语言的一部分。它们纯粹是为了说明目的而由本规范定义的。然而,ECMAScript 实现中的每个对象必须按照与其相关联的内部方法指定的行为方式行事。实现的具体方式由实现决定。
内部方法名称是多态的。这意味着不同的对象值在调用相同的内部方法名称时可能会执行不同的算法。实际调用内部方法的对象是调用的“目标”。如果在运行时,算法的实现尝试使用对象不支持的内部方法,则会抛出
内部槽对应于与对象相关联并被各种 ECMAScript 规范算法使用的内部状态。内部槽不是对象属性,也不会被继承。
根据特定的内部槽规范,这种状态可能由任何
所有对象都有一个名为 [[PrivateElements]] 的内部槽,它是一个
内部方法和内部槽在本规范中使用双括号 [[ ]] 括起来的名称进行标识。
一个 普通对象 是满足以下所有条件的对象:
一个 外来对象 是一个不是
本规范通过这些对象的内部方法识别不同种类的
除了其参数外,内部方法总是可以访问作为方法调用目标的对象。
内部方法隐式返回一个
| 内部方法 | 签名 | 描述 |
|---|---|---|
| [[GetPrototypeOf]] | ( ) → Object | Null |
确定为该对象提供继承属性的对象。 |
| [[SetPrototypeOf]] | (Object | Null) → Boolean |
将该对象与提供继承属性的另一个对象关联。传递 |
| [[IsExtensible]] | ( ) → Boolean | 确定是否允许向该对象添加更多属性。 |
| [[PreventExtensions]] | ( ) → Boolean |
控制是否可以向该对象添加新属性。返回 |
| [[GetOwnProperty]] |
(propertyKey) → Undefined | |
返回该对象自身属性的 |
| [[DefineOwnProperty]] | (propertyKey, 属性描述符) → Boolean |
创建或修改自身属性,其键为 propertyKey,具有 属性描述符 描述的状态。返回 |
| [[HasProperty]] | (propertyKey) → Boolean | 返回一个布尔值,指示该对象是否已经具有键为 propertyKey 的自身或继承属性。 |
| [[Get]] | (propertyKey, Receiver) → any |
从该对象返回键为 propertyKey 的属性的值。如果需要执行 ECMAScript 代码来检索属性值,Receiver 用作评估代码时的
|
| [[Set]] | (propertyKey, value, Receiver) → Boolean |
将键为 propertyKey 的属性的值设置为 value。如果需要执行 ECMAScript
代码来设置属性值,Receiver 用作评估代码时的 |
| [[Delete]] | (propertyKey) → Boolean |
从该对象中删除键为 propertyKey 的自身属性。如果属性未删除且仍存在,返回 |
| [[OwnPropertyKeys]] |
( ) → |
返回一个 |
| 内部方法 | 签名 | 描述 |
|---|---|---|
| [[Call]] |
(any, a |
执行与此对象关联的代码。通过函数调用表达式调用。内部方法的参数是一个 |
| [[Construct]] |
(a |
创建一个对象。通过 new 运算符或 super 调用调用。内部方法的第一个参数是一个 super
调用的参数。第二个参数是最初应用 new 运算符的对象。实现此内部方法的对象称为 |
普通对象和标准外来对象的基本内部方法的语义在第
ECMAScript引擎中对象的内部方法必须符合下面指定的不变性列表。普通ECMAScript对象以及本规范中的所有标准
任何实现提供的
实现不得以任何方式允许绕过这些不变性,例如通过提供实现基本内部方法功能的替代接口而不强制执行其不变性。
任何内部方法返回的值必须是一个
由于第三个不变性的结果,如果一个属性被描述为
众所周知的内在对象是内置对象,它们在本规范的算法中被明确引用,并且通常具有与
在本规范中,诸如%name%的引用意味着与当前
| 内置名称 | 全局名称 | ECMAScript 语言关联 |
|---|---|---|
|
|
AggregateError
|
AggregateError |
|
|
Array
|
Array |
|
|
ArrayBuffer
|
ArrayBuffer |
|
|
数组迭代器对象的原型 ( |
|
|
|
async-from-sync 迭代器对象的原型 ( |
|
|
|
异步函数对象的 |
|
|
|
异步迭代器对象的 |
|
|
|
所有标准内置异步迭代器对象间接继承的对象 | |
|
|
Atomics
|
Atomics 对象 ( |
|
|
BigInt
|
BigInt |
|
|
BigInt64Array
|
BigInt64Array |
|
|
BigUint64Array
|
BigUint64Array |
|
|
布尔值
|
布尔值 |
|
|
数据视图
|
数据视图 |
|
|
Date
|
Date |
|
|
decodeURI
|
decodeURI 函数 ( |
|
|
decodeURIComponent
|
decodeURIComponent 函数 ( |
|
|
encodeURI
|
encodeURI 函数 ( |
|
|
encodeURIComponent
|
encodeURIComponent 函数 ( |
|
|
Error
|
Error |
|
|
eval
|
eval 函数 ( |
|
|
EvalError
|
EvalError |
|
|
FinalizationRegistry
|
|
|
|
Float32Array
|
Float32Array |
|
|
Float64Array
|
Float64Array |
|
|
For-In 迭代器对象的原型 ( |
|
|
|
Function
|
Function |
|
|
生成器的构造函数 ( |
|
|
|
Int8Array
|
Int8Array |
|
|
Int16Array
|
Int16Array |
|
|
Int32Array
|
Int32Array |
|
|
isFinite
|
isFinite 函数 ( |
|
|
isNaN
|
isNaN 函数 ( |
|
|
所有标准内置迭代器对象间接继承的对象 | |
|
|
JSON
|
JSON 对象 ( |
|
|
Map
|
Map |
|
|
Map 迭代器对象的原型 ( |
|
|
|
Math
|
Math 对象 ( |
|
|
Number
|
Number |
|
|
Object
|
Object |
|
|
parseFloat
|
parseFloat 函数 ( |
|
|
parseInt
|
parseInt 函数 ( |
|
|
Promise
|
Promise |
|
|
Proxy
|
Proxy |
|
|
RangeError
|
RangeError |
|
|
ReferenceError
|
ReferenceError |
|
|
Reflect
|
Reflect 对象 ( |
|
|
RegExp
|
RegExp |
|
|
正则表达式字符串迭代器对象的原型 ( |
|
|
|
Set
|
Set |
|
|
Set 迭代器对象的原型 ( |
|
|
|
SharedArrayBuffer
|
SharedArrayBuffer |
|
|
String
|
String |
|
|
字符串迭代器对象的原型 ( |
|
|
|
Symbol
|
Symbol |
|
|
SyntaxError
|
SyntaxError |
|
|
一个 |
|
|
|
所有类型化数组 |
|
|
|
TypeError
|
TypeError |
|
|
Uint8Array
|
Uint8Array |
|
|
Uint8ClampedArray
|
Uint8ClampedArray |
|
|
Uint16Array
|
Uint16Array |
|
|
Uint32Array
|
Uint32Array |
|
|
URIError
|
URIError |
|
|
WeakMap
|
WeakMap |
|
|
WeakRef
|
|
|
|
WeakSet
|
WeakSet |
在
规范类型对应于在算法中使用的元值,用于描述 ECMAScript 语言结构和
枚举是规范内部的值,不能直接从 ECMAScript 代码中观察到。枚举用
列表类型用于解释参数列表的评估(参见 new 表达式、函数调用和其他需要简单有序值列表的算法中。列表类型的值是包含各个值的列表元素的简单有序序列。这些序列可以是任意长度的。列表元素可以使用基于 0
的索引随机访问。为了表示方便,可以使用类似数组的语法来访问列表元素。例如,arguments[2] 是表示列表 arguments 的第 3 个元素的简写。
当算法迭代列表元素而不指定顺序时,使用的顺序是列表中元素的顺序。
为了在本规范中表示方便,可以使用字面量语法来表示新的列表值。例如,« 1, 2 » 定义了一个包含两个元素的列表值,每个元素初始化为特定值。一个新的空列表可以表示为 « »。
在本规范中,短语“列表连接 A、B、...”(其中每个参数是一个可能为空的列表)表示一个新列表值,其元素是每个参数(按顺序)的元素(按顺序)的连接。
记录类型用于描述本规范算法中的数据聚合。记录类型值由一个或多个命名字段组成。每个字段的值是一个
为了在本规范中表示方便,可以使用类似对象字面量的语法来表示记录值。例如,{ [[Field1]]: 42, [[Field2]]:
在规范文本和算法中,可以使用点表示法来引用记录值的特定字段。例如,如果 R 是前一段中显示的记录,则 R.[[Field2]] 是“R 中名为 [[Field2]] 的字段”的简写。
常用记录字段组合的模式可以命名,并且该名称可以用作字面量记录值的前缀,以标识所描述的特定聚合类型。例如:PropertyDescriptor { [[Value]]:
42, [[Writable]]:
集合类型用于解释
关系类型用于解释对集合的约束。关系类型的值是其值域中值的有序对集合。例如,事件上的关系是事件的有序对集合。对于关系 R 和 R 值域中的两个值 a 和 b,a R b 是表示有序对 (a, b) 是 R 成员的简写。关系在某些条件下是最小的,当它是满足这些条件的最小关系时。
严格偏序是满足以下条件的关系值 R:
对于 R 域中的所有 a、b 和 c:
上述两个属性分别称为非自反性和传递性。
严格全序是满足以下条件的关系值 R:
对于 R 域中的所有 a、b 和 c:
上述三个属性分别称为完全性、非自反性和传递性。
完成记录规范类型用于解释值和控制流的运行时传播,例如执行非本地控制转移的语句(break、continue、return
和 throw)的行为。
完成记录具有
以下简短术语有时用于指代完成记录。
本规范中定义的可调用对象仅返回正常完成或抛出完成。返回任何其他类型的完成记录被视为编辑错误。
抽象操作 NormalCompletion 接受参数 value(任何值,除了
抽象操作 ThrowCompletion 接受参数 value(一个
抽象操作 UpdateEmpty 接受参数 completionRecord(一个
引用记录类型用于解释
delete、typeof、赋值运算符、super
引用记录是已解析的名称或属性绑定;其字段由
| 字段名称 | 值 | 含义 |
|---|---|---|
| [[Base]] | 一个 |
持有绑定的值或 |
| [[ReferencedName]] | 字符串、符号或 |
绑定的名称。如果 [[Base]] 值是 |
| [[Strict]] | 布尔值 | |
| [[ThisValue]] | 一个 |
如果不是 super |
以下
抽象操作 IsPropertyReference 接受参数 V(一个
抽象操作 IsUnresolvableReference 接受参数 V(一个
抽象操作 IsSuperReference 接受参数 V(一个
抽象操作 IsPrivateReference 接受参数 V(一个
抽象操作 GetValue 接受参数 V(一个
抽象操作 PutValue 接受参数 V(一个
抽象操作GetThisValue接受参数V(一个
抽象操作InitializeReferencedBinding接受参数V(一个
抽象操作MakePrivateReference接受参数baseValue(一个
属性描述符类型用于解释对象属性属性的操作和具体化。属性描述符是一个
属性描述符值可以根据某些字段的存在或使用进一步分类为数据属性描述符和访问器属性描述符。数据属性描述符是包含名为[[Value]]或[[Writable]]的字段的描述符。访问器属性描述符是包含名为[[Get]]或[[Set]]的字段的描述符。任何属性描述符都可能包含名为[[Enumerable]]和[[Configurable]]的字段。属性描述符值不能同时是数据属性描述符和访问器属性描述符;然而,它可以既不是(在这种情况下,它是一个通用属性描述符)。一个完全填充的属性描述符是访问器属性描述符或数据属性描述符,并且具有
以下
抽象操作IsAccessorDescriptor接受参数Desc(一个
抽象操作IsDataDescriptor接受参数Desc(一个
抽象操作IsGenericDescriptor接受参数Desc(一个
抽象操作FromPropertyDescriptor接受参数Desc(一个
抽象操作ToPropertyDescriptor接受参数Obj(一个
抽象操作CompletePropertyDescriptor接受参数Desc(一个
抽象闭包规范类型用于引用算法步骤以及一组值。抽象闭包通过函数应用风格调用,例如closure(arg1, arg2)。与
在创建抽象闭包的算法步骤中,值通过“捕获”动词后跟别名列表来捕获。当创建抽象闭包时,它会捕获创建时与每个别名关联的值。在指定抽象闭包被调用时要执行的算法步骤中,每个捕获的值通过用于捕获该值的别名来引用。
如果抽象闭包返回一个
抽象闭包作为其他算法的一部分内联创建,如下例所示。
数据块规范类型用于描述一个独特且可变的字节大小(8位)数值序列。字节值是一个
为了在本规范中表示方便,可以使用类似数组的语法来访问数据块值的各个字节。这种表示法将数据块值呈现为从0开始的
驻留在可以被多个
共享数据块的语义通过
以下
抽象操作CreateByteDataBlock接受参数size(一个非负
抽象操作 CreateSharedByteDataBlock 接受参数 size(一个非负的
抽象操作 CopyDataBlockBytes 接受参数 toBlock(一个
私有元素类型是一个
私有元素类型的值是
| 字段名称 | [[Kind]] 字段值 | 值 | 含义 |
|---|---|---|---|
| [[Key]] | 所有 |
一个 |
字段、方法或访问器的名称。 |
| [[Kind]] | 所有 |
|
元素的种类。 |
| [[Value]] |
|
一个 |
字段的值。 |
| [[Get]] |
|
一个 |
私有访问器的 getter。 |
| [[Set]] |
|
一个 |
私有访问器的 setter。 |
类字段定义类型是一个
类字段定义类型的值是
私有名称规范类型用于描述一个全局唯一的值(不同于任何其他私有名称,即使它们在其他方面无法区分),该值表示私有类元素(字段、方法或访问器)的键。每个私有名称都有一个关联的不可变 [[Description]],它是一个
类静态块定义记录是一个
类静态块定义记录的字段列在
这些操作不是 ECMAScript 语言的一部分;它们在这里仅用于帮助规范 ECMAScript 语言的语义。其他更专业的
ECMAScript 语言在需要时隐式执行自动类型转换。为了阐明某些结构的语义,定义了一组转换
ECMAScript 语言中的
抽象操作 ToPrimitive 接受参数 input(一个
当 ToPrimitive 被调用时不带提示时,它的行为通常类似于提示为
抽象操作 OrdinaryToPrimitive 接受参数 O(一个对象)和 hint
(
抽象操作 ToBoolean 接受参数 argument(一个
抽象操作 ToNumeric 接受参数 value(一个
抽象操作 ToNumber 接受参数 argument(一个
抽象操作
所有未明确定义的语法符号均使用词法语法中为数字字面量定义的定义(
抽象操作 StringToNumber 接受参数 str(一个字符串)并返回一个数字。 当调用时,它执行以下步骤:
语法导向操作
将
它在以下产生式上分段定义:
抽象操作 RoundMVResult 接受参数 n(一个
抽象操作 ToIntegerOrInfinity 接受参数 argument(一个
抽象操作 ToInt32 接受参数 argument(一个
根据上述 ToInt32 的定义:
抽象操作 ToUint32 接受参数 argument(一个
抽象操作 ToInt16 接受参数 argument(一个
抽象操作 ToUint16 接受参数 argument(一个
根据上述 ToUint16 的定义:
抽象操作 ToInt8 接受参数 argument(一个
抽象操作ToUint8接受参数argument(一个ECMAScript语言值),并返回一个包含整数Number的正常完成或一个抛出完成。它将argument转换为从
抽象操作 ToUint8Clamp 接受参数 argument(一个
与大多数其他 ECMAScript Math.round
抽象操作 ToBigInt 接受参数 argument(一个
| 参数类型 | 结果 |
|---|---|
| Undefined | 抛出 |
| Null | 抛出 |
| Boolean | 如果 prim 是 1n;如果 prim 是
0n。
|
| BigInt | 返回 prim。 |
| Number | 抛出 |
| String |
|
| Symbol | 抛出 |
抽象操作 StringToBigInt 接受参数 str(一个字符串)并返回一个 BigInt 或
抽象操作 ToBigInt64 接受参数 argument(一个
抽象操作 ToBigUint64 接受参数 argument(一个
抽象操作 ToString 接受参数 argument(一个
抽象操作 ToObject 接受参数 argument(一个
| 参数类型 | 结果 |
|---|---|
| Undefined | 抛出一个 |
| Null | 抛出一个 |
| Boolean | 返回一个新的布尔对象,其 [[BooleanData]] 内部槽被设置为 argument。参见 |
| Number | 返回一个新的数字对象,其 [[NumberData]] 内部槽被设置为 argument。参见 |
| String | 返回一个新的字符串对象,其 [[StringData]] 内部槽被设置为 argument。参见 |
| Symbol | 返回一个新的符号对象,其 [[SymbolData]] 内部槽被设置为 argument。参见 |
| BigInt | 返回一个新的 BigInt 对象,其 [[BigIntData]] 内部槽被设置为 argument。参见
|
| Object | 返回 argument。 |
抽象操作 ToPropertyKey 接受参数 argument(一个
抽象操作 ToLength 接受参数 argument(一个
抽象操作 CanonicalNumericIndexString 接受参数 argument(一个字符串)并返回一个数字或
一个规范数字字符串是任何使 CanonicalNumericIndexString
抽象操作不返回
抽象操作 ToIndex 接受参数 value(一个
抽象操作 RequireObjectCoercible 接受参数 argument(一个
| 参数类型 | 结果 |
|---|---|
| Undefined | 抛出一个 |
| Null | 抛出一个 |
| Boolean | 返回 argument。 |
| Number | 返回 argument。 |
| String | 返回 argument。 |
| Symbol | 返回 argument。 |
| BigInt | 返回 argument。 |
| Object | 返回 argument。 |
抽象操作 IsArray 接受参数 argument(一个
抽象操作 IsCallable 接受参数 argument(一个
抽象操作 IsConstructor 接受参数 argument(一个
抽象操作 IsExtensible 接受参数 O(一个对象),并返回一个
抽象操作 IsIntegralNumber 接受参数 argument(一个
抽象操作 IsPropertyKey 接受参数 argument(一个
抽象操作 IsRegExp 接受参数 argument(一个
抽象操作 IsStringWellFormedUnicode 接受参数 string(一个字符串),并返回一个布尔值。它将 string 解释为一系列 UTF-16
编码的代码点,如
抽象操作 SameValue 接受参数 x(一个
这个算法不同于
抽象操作 SameValueZero 接受参数 x(一个
SameValueZero 与
抽象操作 SameValueNonNumber 接受参数 x(一个
抽象操作 IsLessThan 接受参数 x(一个
字符串的比较使用简单的按 UTF-16 代码单元值序列的字典顺序,没有尝试使用 Unicode 规范中定义的更复杂的、语义导向的字符或字符串相等性和排序顺序定义。因此,根据 Unicode
标准正规等价但不在相同规范化形式中的字符串值可能会被测试为不等。同样需要注意的是,对于包含
抽象操作 IsLooselyEqual 接受参数 x(一个 == 操作符的语义。它在被调用时执行以下步骤:
抽象操作 IsStrictlyEqual 接受参数 x(一个 === 操作符的语义。调用时执行以下步骤:
该算法在处理有符号零和 NaN 时与
抽象操作 MakeBasicObject 接受参数 internalSlotsList(一个
在本规范中,
抽象操作 Get 接受参数 O(一个对象)和 P(一个
抽象操作 GetV 接受参数 V(一个
抽象操作 Set 接受参数 O(一个对象)、P(一个
抽象操作 CreateDataProperty 接受参数 O(一个对象)、P(一个
此抽象操作创建一个属性,其属性设置为 ECMAScript 语言赋值运算符创建的默认值。通常,该属性不会已存在。如果存在且不可配置,或者 O 不可扩展,则 [[DefineOwnProperty]] 将返回
抽象操作 CreateDataPropertyOrThrow 接受参数 O(一个对象)、P(一个
此抽象操作创建一个属性,其属性设置为 ECMAScript 语言赋值运算符创建的默认值。通常,该属性不会已存在。如果存在且不可配置,或者 O 不可扩展,则 [[DefineOwnProperty]] 将返回
抽象操作 CreateNonEnumerableDataPropertyOrThrow 接受参数 O(一个对象)、P(一个
此抽象操作创建一个属性,其属性设置为与 ECMAScript 语言赋值运算符创建的默认值相同,但不可枚举。通常情况下,该属性不存在。如果存在,则
抽象操作 DefinePropertyOrThrow 接受参数 O(一个对象)、P(一个
抽象操作 DeletePropertyOrThrow 接受参数 O(一个对象)和 P(一个
抽象操作 GetMethod 接受参数 V(一个
抽象操作 HasProperty 接受参数 O(一个 Object)和 P(一个
抽象操作 HasOwnProperty 接受参数 O(一个 Object)和 P(一个
抽象操作 Call 接受参数 F(一个
抽象操作构造(Construct)接受参数F(一个
如果newTarget不存在,则该操作等效于:new F(...argumentsList)
抽象操作 SetIntegrityLevel 接受参数 O(一个对象)和 level(
抽象操作 TestIntegrityLevel 接受参数 O(一个对象)和 level(
抽象操作 CreateArrayFromList 接受参数 elements(一个
抽象操作 LengthOfArrayLike 接受参数 obj(一个对象)并返回一个
类似数组对象是指该操作返回
抽象操作 CreateListFromArrayLike 接受参数 obj(一个
抽象操作 Invoke 接受参数 V(一个
抽象操作 OrdinaryHasInstance 接受参数 C(一个
抽象操作 SpeciesConstructor 接受参数 O(一个对象)和 defaultConstructor(一个
抽象操作 EnumerableOwnProperties 接受参数 O(一个对象)和 kind
(
抽象操作 GetFunctionRealm 接受参数 obj(一个
抽象操作 CopyDataProperties 接受参数 target(一个对象),source
(一个
这里传入的目标对象始终是一个新创建的对象,在发生错误抛出时不会直接访问到它。
抽象操作 PrivateElementFind 接受参数 O(一个对象)和 P(一个
抽象操作 PrivateFieldAdd 接受参数 O(一个对象),P(一个
抽象操作 PrivateMethodOrAccessorAdd 接受参数 O(一个对象)和 method(一个
私有方法和访问器的值在实例之间是共享的。此操作不会创建方法或访问器的新副本。
主机定义的抽象操作 HostEnsureCanAddPrivateElement 接受参数 O(一个对象),并返回一个包含正常完成的
HostEnsureCanAddPrivateElement 的实现必须符合以下要求:
HostEnsureCanAddPrivateElement 的默认实现是返回
此抽象操作仅由 ECMAScript
抽象操作 PrivateGet 接受参数 O(一个对象)和 P(一个私有名称),并返回一个包含 ECMAScript 语言值的普通完成或抛出完成。调用时执行以下步骤:
抽象操作 PrivateSet 接受参数 O(一个对象)、P(一个私有名称)和 value(一个 ECMAScript 语言值),并返回一个包含未使用的普通完成或抛出完成。调用时执行以下步骤:
抽象操作 DefineField 接受参数 receiver(一个对象)和 fieldRecord(一个
抽象操作 InitializeInstanceElements 接受参数 O(一个对象)和 constructor(一个 ECMAScript
抽象操作 AddValueToKeyedGroup 接受参数 groups(一个包含字段 [[Key]](一个 ECMAScript
语言值)和 [[Elements]](一个 ECMAScript 语言值列表)的
抽象操作 GroupBy 接受参数 items(一个 ECMAScript 语言值)、callbackfn(一个 ECMAScript 语言值)和
keyCoercion(
请参阅通用迭代接口(
迭代器记录是用于封装迭代器或异步迭代器及其 next 方法的
迭代器记录具有以下在
| 字段名 | 值 | 含义 |
|---|---|---|
| [[Iterator]] | 一个对象 | 符合 Iterator 或 AsyncIterator 接口的对象。 |
| [[NextMethod]] |
一个 |
[[Iterator]] 对象的 next 方法。
|
| [[Done]] | 一个布尔值 | 表示迭代器是否已关闭。 |
抽象操作 GetIteratorFromMethod 接受参数 obj(一个
抽象操作 GetIterator 接受参数 obj(一个 ECMAScript 语言值)和 kind(
抽象操作 IteratorNext 接受参数 iteratorRecord(一个
抽象操作 IteratorComplete 接受参数 iterResult(一个对象)并返回一个包含正常完成状态的布尔值或抛出异常完成状态。调用时执行以下步骤:
抽象操作 IteratorValue 接受参数 iterResult(一个对象)并返回一个包含正常完成状态的 ECMAScript 语言值或抛出异常完成状态。调用时执行以下步骤:
抽象操作 IteratorStep 接受参数 iteratorRecord(一个
抽象操作 IteratorStepValue 接受参数 iteratorRecord(一个
抽象操作 IteratorClose 接受参数 iteratorRecord(一个
IfAbruptCloseIterator 是一个使用
意味着与以下内容相同:
异步抽象操作 AsyncIteratorClose 接受参数 iteratorRecord (一个
抽象操作 CreateIterResultObject 接受参数 value (一个
抽象操作 CreateListIteratorRecord 接受参数 list (一个 next 方法返回
list 的连续元素。在调用时执行以下步骤:
列表迭代器对象对 ECMAScript 代码不可直接访问。
抽象操作 IteratorToList 接受参数 iteratorRecord (一个
除了本节中定义的操作外,专门的
语法导向操作 Evaluation 不接受参数并返回一个
语法指导操作 BoundNames 不接受参数,并返回一个字符串列表(List)。
它在以下产生式上分段定义:
DeclarationPart 是一个语法指导操作,不接受参数并返回一个解析节点(Parse Node)。它根据以下产生式逐段定义:
没有必要将 export default
在
export
在
本节由附录
export
VarScopedDeclarations是一个无需参数并返回
本节由附件
export 在函数或脚本的顶层,函数声明被视为 var 声明,而不是词法声明。
静态语义操作 TopLevelLexicallyScopedDeclarations 不接受参数,并返回一个
语法定向操作 TopLevelVarDeclaredNames 不接受参数,并返回一个
在函数或脚本的顶层,内部函数声明被视为 var 声明。
The
此部分由附录
语法定向操作 ContainsUndefinedBreakTarget 接受参数 labelSet(一个字符串
此部分由附件
语法定向操作 ContainsUndefinedContinueTarget 接受参数 iterationSet(一个字符串
本节由附录
抽象操作 IsAnonymousFunctionDefinition 接受参数 expr(一个
本规范中未列出的每个语法生成替代方案都隐含具有以下默认的 Contains 定义:
依赖于子结构的静态语义规则通常不会深入查看函数定义。
Static semantic rules that depend upon substructure generally do not look into class bodies except
for
依赖子结构的静态语义规则通常不会检查static初始化块。
super 或
this 之一,则返回 super,或
this,返回 super,或
this,返回 Contains is used to detect new.target, this, and super usage
within an
super,返回
这些操作在整个规范的多个地方使用。
它在以下生成式中逐段定义:
抽象操作 InitializeBoundName 接受参数 name(字符串),value(一个
它通过以下生成式逐段定义:
语法指导操作
环境记录是一种规范类型,用于根据 ECMAScript 代码的词法嵌套结构,定义
每个环境记录都有一个[[OuterEnv]]字段,它要么是
环境记录纯粹是规范机制,不需要对应于 ECMAScript 实现的任何具体产物。ECMAScript 程序不可能直接访问或操作这些值。
| 方法 | 用途 |
|---|---|
| HasBinding(N) | 确定 |
| CreateMutableBinding(N, D) | 在 |
| CreateImmutableBinding(N, S) | 在 |
| InitializeBinding(N, V) | 设置 |
| SetMutableBinding(N, V, S) | 设置 |
| GetBindingValue(N, S) | 返回 |
| DeleteBinding(N) | 从 |
| HasThisBinding() | 确定this绑定。如果建立了,返回 |
| HasSuperBinding() | 确定super方法绑定。如果建立了,返回 |
| WithBaseObject() | 如果此with语句关联,则返回
with 对象。否则,返回 |
每个声明式环境记录都与包含变量、常量、let、class、模块、import和/或函数声明的 ECMAScript 程序范围相关联。声明式环境记录绑定其范围内包含的声明所定义的一组标识符。
声明式环境记录的具体规范方法的行为由以下算法定义。
在步骤
function f() { eval("var x; x = (delete x, 0);"); }
每个对象环境记录都与一个称为绑定对象的对象相关联。对象环境记录绑定一组字符串标识符名称,这些名称直接对应于其绑定对象的属性名称。
为with语句创建的对象环境记录(
对象环境记录具有
对象环境记录的具体规范方法的行为由以下算法定义。
通常情况下,envRec不会有N的绑定,但如果有,
this绑定。
super绑定。
函数环境记录 是一种
this绑定。如果函数不是一个super,则其函数环境记录还包含用于在函数内部执行super方法调用的状态。
函数环境记录具有
| 字段名称 | 值 | 含义 |
|---|---|---|
| [[ThisValue]] |
一个 |
这是该函数调用中使用的 |
| [[ThisBindingStatus]] |
|
如果值是 |
| [[FunctionObject]] |
一个ECMAScript |
导致创建此 |
| [[NewTarget]] |
一个对象或 |
如果此 |
函数环境记录支持
函数环境记录附加具体方法的行为由以下算法定义:
函数环境记录
函数环境记录
函数环境记录
函数环境记录
函数环境记录
全局环境记录用于表示所有在同一个
全局环境记录在逻辑上是一个单一的记录,但它被指定为一个复合体,封装了一个
属性可以直接在
全局环境记录具有
| 字段名称 | 值 | 含义 |
|---|---|---|
| [[ObjectRecord]] |
一个 |
绑定对象是 |
| [[GlobalThisValue]] | 一个对象 |
全局作用域中this返回的值。 |
| [[DeclarativeRecord]] |
一个 |
|
| [[VarNames]] |
一个 |
在相关 |
| 方法 | 目的 |
|---|---|
| GetThisBinding() |
返回此this绑定的值。
|
| HasVarDeclaration (N) |
确定参数标识符是否在此 |
| HasLexicalDeclaration (N) |
确定参数标识符是否在此 |
| HasRestrictedGlobalProperty (N) |
确定参数是否为 |
| CanDeclareGlobalVar (N) | 确定是否可以成功调用相应的CreateGlobalVarBinding方法,并为相同的参数N声明全局变量。 |
| CanDeclareGlobalFunction (N) | 确定是否可以成功调用相应的CreateGlobalFunctionBinding方法,并为相同的参数N声明全局函数。 |
| CreateGlobalVarBinding(N, D) |
用于在[[ObjectRecord]]组件中创建并初始化一个全局var绑定,
该绑定的初始值为var的属性值。
字符串值N是绑定的名称。如果D为 |
| CreateGlobalFunctionBinding(N, V, D) |
在[[ObjectRecord]]组件中创建并初始化一个全局function绑定。
绑定将是可变绑定。相应的function的属性值。
字符串值N是绑定的名称。V是初始化值。
如果布尔参数D为 |
具体规范方法的行为定义如下算法。
全局环境记录envRec的HasBinding具体方法接受参数N(字符串),返回一个
全局环境记录envRec的CreateMutableBinding具体方法接受参数N(字符串)和D(布尔值),返回一个
全局环境记录envRec的CreateImmutableBinding具体方法接受参数N(字符串)和S(布尔值),返回一个
全局环境记录envRec的InitializeBinding具体方法接受参数N(字符串)和V(
全局环境记录envRec的SetMutableBinding具体方法接受参数N(字符串)、V(
全局环境记录envRec的GetBindingValue具体方法接受参数N(字符串)和S(布尔值),返回一个
全局环境记录envRec的DeleteBinding具体方法接受参数N(字符串),返回一个
全局环境记录envRec的HasThisBinding具体方法不接受参数,返回
this绑定。
全局环境记录envRec的HasSuperBinding具体方法不接受参数,返回
super绑定。
全局环境记录envRec的WithBaseObject具体方法不接受参数,返回
全局环境记录envRec的GetThisBinding具体方法不接受参数,返回一个
全局环境记录envRec的HasVarDeclaration具体方法接受参数N(字符串),返回一个布尔值。它确定参数标识符是否在此记录中具有通过
全局环境记录envRec的HasLexicalDeclaration具体方法接受参数N(字符串),返回一个布尔值。它确定参数标识符是否在此记录中具有通过词法声明(如
全局环境记录envRec的HasRestrictedGlobalProperty具体方法接受参数N(字符串),返回一个
全局环境记录envRec的CanDeclareGlobalVar具体方法接受参数N(字符串),返回一个
全局环境记录envRec的CanDeclareGlobalFunction具体方法接受参数N(字符串),返回一个
全局环境记录envRec的CreateGlobalVarBinding具体方法接受参数N(字符串)和D(布尔值),返回一个
全局环境记录envRec的CreateGlobalFunctionBinding具体方法接受参数N(字符串)、V(
模块环境记录 是一种
模块环境记录支持所有在
模块环境记录的附加具体规范方法的行为由以下算法定义:
模块环境记录的 GetBindingValue 具体方法 envRec 接受参数 N(字符串)和 S(布尔值),返回一个包含
ECMAScript 语言值的正常完成记录或抛出完成记录。它返回其绑定标识符 N 的值。但是,如果绑定是间接绑定,则返回目标绑定的值。如果绑定存在但未初始化,则抛出
S 将始终为
模块环境记录的 DeleteBinding 具体方法在本规范中从未使用。
模块环境记录的 HasThisBinding 具体方法 envRec 不接受任何参数并返回
模块环境记录始终提供 this 绑定。
模块环境记录的 GetThisBinding 具体方法 envRec 不接受任何参数并返回
模块环境记录的 CreateImportBinding 具体方法 envRec 接受参数 N(字符串)、M(模块记录)和 N2(字符串),并返回
抽象操作 GetIdentifierReference 接受参数 env(一个
抽象操作 NewDeclarativeEnvironment 接受参数 E(一个
抽象操作 NewObjectEnvironment 接受参数 O(一个对象)、W(布尔值)和 E(一个
抽象操作 NewFunctionEnvironment 接受参数 F(一个 ECMAScript
抽象操作 NewGlobalEnvironment 接受参数 G(一个对象)和 thisValue(一个对象),返回一个
抽象操作 NewModuleEnvironment 接受参数 E(一个
私有环境记录 是一种用于根据
ECMAScript 代码中的
抽象操作 NewPrivateEnvironment 接受参数 outerPrivEnv(一个
抽象操作 ResolvePrivateIdentifier 接受参数 privEnv(一个
在评估之前,所有 ECMAScript 代码都必须与一个 范围 相关联。从概念上讲,一个
本规范中以 范围记录 表示
| 字段名称 | 值 | 含义 |
|---|---|---|
| [[AgentSignifier]] | 一个 |
拥有此 |
| [[Intrinsics]] | 一个 |
与此 |
| [[GlobalObject]] | 一个对象或 |
此 |
| [[GlobalEnv]] | 一个 |
此 |
| [[TemplateMap]] | 一个 |
模板对象在每个 一旦
|
| [[LoadedModules]] | 一个 |
从此 正如在
import() 表达式时使用。
|
| [[HostDefined]] | 任何(默认值为 |
为 |
抽象操作 CreateRealm 不接受任何参数并返回一个
抽象操作 CreateIntrinsics 接受参数 realmRec(一个
抽象操作 SetRealmGlobalObject 接受参数 realmRec(一个
抽象操作 SetDefaultGlobalBindings 接受参数 realmRec(一个
执行上下文 是一个规范设备,用于跟踪 ECMAScript 实现对代码的运行时评估。在任何时候,每个
执行上下文堆栈
用于跟踪执行上下文。
执行上下文包含所有跟踪其关联代码执行进度的必要实现特定状态。每个执行上下文至少有
ECMAScript 代码执行上下文 具有
执行上下文的词法环境和变量环境组件始终是
表示生成器评估的执行上下文具有
| 组件 | 目的 |
|---|---|
| 生成器 | 此 |
在大多数情况下,仅由此规范中的算法直接操作
执行上下文纯粹是一个规范机制,不需要对应于 ECMAScript 实现的任何特定制品。ECMAScript 代码不可能直接访问或观察到执行上下文。
抽象操作 GetActiveScriptOrModule 不接受参数,并返回
抽象操作 ResolveBinding 接受参数 name(一个字符串)和可选参数 env(一个
ResolveBinding 的结果始终是一个
抽象操作 GetThisEnvironment 不接受参数,并返回一个 this
绑定的
步骤 this 绑定的全局环境结束。
抽象操作 ResolveThisBinding 不接受参数,并返回 this 的绑定。调用时执行以下步骤:
抽象操作 GetNewTarget 不接受参数,并返回一个对象或
抽象操作 GetGlobalObject 不接受参数并返回一个对象。它返回由当前
作业是一个无参数的
在任何特定时间,如果以下所有条件都为真,则scriptOrModule(一个
在任何特定时间,如果以下所有条件都为真,则执行准备好评估 ECMAScript 代码:
特定种类的
作业回调记录是一个
WHATWG HTML 规范(https://html.spec.whatwg.org/)例如,使用宿主定义的值传播 Promise 回调的现有设置对象。
作业回调记录具有
HostMakeJobCallback 的实现必须符合以下要求:
HostMakeJobCallback 的默认实现在调用时执行以下步骤:
不是网络浏览器的 ECMAScript 宿主必须使用 HostMakeJobCallback 的默认实现。
这在将回调传递给负责其最终调度和运行的函数时调用。例如,promise.then(thenAction)在调用Promise.prototype.then时调用
MakeJobCallback
在调用Promise.prototype.then时调用 MakeJobCallback,而不是在调度反应作业时。
HostCallJobCallback 的实现必须符合以下要求:
此要求意味着宿主不能更改本规范中定义的函数对象的[[Call]]行为。
HostCallJobCallback 的默认实现在调用时执行以下步骤:
不是网络浏览器的 ECMAScript 宿主必须使用 HostCallJobCallback 的默认实现。
HostEnqueueGenericJob 的实现必须符合
HostEnqueuePromiseJob 的实现必须符合
通过
HostEnqueueTimeoutJob 的实现必须符合
抽象操作 InitializeHostDefinedRealm 不接受任何参数,返回一个包含
this 绑定在 realm
的全局作用域中返回一个不同于 this 绑定应为 一个代理包括一组ECMAScript
一个
一些网络浏览器会在多个不相关的浏览器窗口标签页之间共享单个
当一个
一个代理标识符是一个全局唯一的、不透明的值,用于标识一个
| 字段名 | 值 | 含义 |
|---|---|---|
| [[LittleEndian]] | 布尔值 | 在算法 |
| [[CanBlock]] | 布尔值 | 确定 |
| [[Signifier]] | 一个 |
唯一标识其 |
| [[IsLockFree1]] | 布尔值 | 如果对一个字节大小值的原子操作是无锁的,则为 |
| [[IsLockFree2]] | 布尔值 | 如果对两字节大小值的原子操作是无锁的,则为 |
| [[IsLockFree8]] | 布尔值 | 如果对八字节大小值的原子操作是无锁的,则为 |
| [[CandidateExecution]] | 一个 |
参见 |
| [[KeptAlive]] | 一个 |
最初是一个新的空 |
一旦[[Signifier]]、[[IsLockFree1]]和[[IsLockFree2]]的值被任何
[[IsLockFree1]]和[[IsLockFree2]]的值不一定由硬件决定,还可能反映出可能随时间和不同ECMAScript实现而变化的实现选择。
没有[[IsLockFree4]]字段:四字节原子操作总是无锁的。
实际上,如果一个原子操作的实现使用了任何类型的锁,则该操作就不是无锁的。无锁不意味着无等待:没有关于完成无锁原子操作需要多少机器步骤的上限。
原子访问大小为n是无锁的,并不意味着对非原子访问大小为n的访问有任何暗示,特别是,非原子访问仍可能作为一系列单独的内存访问执行。详见
一个
抽象操作 AgentSignifier 不接受任何参数,并返回一个
抽象操作 AgentCanSuspend 不接受任何参数,并返回一个布尔值。调用时,它执行以下步骤:
在某些环境中,允许给定
一个代理集群是可以通过操作共享内存进行通信的
每个
集群中的所有
如果一个代理集群中的不同
集群中的所有
集群中的所有
嵌入环境可以在不通知或合作代理的情况下停用(停止前进进程)或激活(恢复前进进程)一个
嵌入环境可以在不通知或合作集群中其他
每个以下的规范值及从它们递归可达的值,只属于一个代理集群。
在集群中任何
代理集群是一个规范机制,不必对应于ECMAScript实现的任何特定工件。
对于一个
当
实现必须确保:
本规范不保证任何对象或符号将被垃圾回收。对于那些不是
WeakRef.prototype.deref时,如果未返回这些操作(
一些 ECMAScript 实现包括在后台运行的垃圾回收器实现,包括 ECMAScript 空闲时。让
对于某些对象和/或符号的集合S,相对于S的假设的 WeakRef-oblivious执行是指抽象操作
在评估过程中,如果对象和/或符号的集合S满足以下任一条件,则被认为是存活的:
对象或符号在字段、内部槽或属性中的存在并不意味着该值是存活的。例如,如果问题中的值从未传递回程序,则无法观察到它。
这是 WeakMap 中的键、WeakSet 的成员以及[[WeakRefTarget]]和[[UnregisterToken]]字段在
上述定义意味着,如果 WeakMap 中的键不是存活的,则其对应的值也不一定是存活的。
在任何时候,如果对象和/或符号的集合S不是
结合存活性的定义,本条款规定了实现可以应用的关于
有可能在不观察对象身份的情况下访问对象。允许对非逃逸对象的属性进行死变量消除和标量替换等优化,因此这些优化可以可观察地清空指向这些对象的
另一方面,如果可以观察到对象的身份,并且该对象位于
由于调用
让cleanupJob成为一个新的
HostEnqueueFinalizationRegistryCleanupJob 的实现会安排在将来的某个时间执行cleanupJob,如果可能的话。它还必须符合
抽象操作 ClearKeptObjects 不接受任何参数并返回
抽象操作 AddToKeptObjects 接受参数 value(一个对象或符号)并返回
抽象操作 CleanupFinalizationRegistry 接受参数 finalizationRegistry(一个
抽象操作 CanBeHeldWeakly 接受参数 v(一个
没有
所有的
每个
在以下算法描述中,假设 O 是一个
每个
[[GetPrototypeOf]] 内部方法用于一个
抽象操作 OrdinaryGetPrototypeOf 接受一个参数 O(一个对象),并返回一个对象或
[[SetPrototypeOf]] 内部方法用于一个
抽象操作 OrdinarySetPrototypeOf 接受两个参数:O(一个对象)和 V(一个对象或
[[IsExtensible]] 内部方法用于一个
抽象操作 OrdinaryIsExtensible 接受一个参数 O(一个对象),并返回一个布尔值。调用时执行以下步骤:
[[PreventExtensions]] 内部方法用于一个
抽象操作 OrdinaryPreventExtensions 接受一个参数 O(一个对象),并返回
[[GetOwnProperty]] 内部方法用于一个
抽象操作 OrdinaryGetOwnProperty 接受两个参数 O(一个对象)和 P(一个
普通对象的 [[DefineOwnProperty]] 内部方法接受两个参数:P(一个
抽象操作 OrdinaryDefineOwnProperty 接受参数 O(一个对象)、P(一个
抽象操作 IsCompatiblePropertyDescriptor 接受参数 Extensible(一个布尔值)、Desc(一个
抽象操作 ValidateAndApplyPropertyDescriptor 接受参数
O(一个对象或
一个
抽象操作 OrdinaryHasProperty 接受参数 O(一个对象)和 P(一个
[[Get]] 内部方法用于一个
抽象操作 OrdinaryGet 接受参数 O(一个对象)、P(一个
普通对象(
抽象操作 OrdinarySet 接受四个参数:O(对象),P(属性键),V(ECMAScript 语言值),和 Receiver(ECMAScript 语言值),并返回一个完成记录,可能是包含布尔值的正常完成记录,也可能是抛出异常的完成记录。调用时执行以下步骤:
抽象操作 OrdinarySetWithOwnDescriptor 接受五个参数:O(对象),P(属性键),V(ECMAScript
语言值),Receiver(ECMAScript 语言值),和 ownDesc(属性描述符或
普通对象(
抽象操作 OrdinaryDelete 接受两个参数:O(对象)和 P(
普通对象(
抽象操作 OrdinaryOwnPropertyKeys 接受一个参数 O(对象),并返回一个包含
抽象操作 OrdinaryObjectCreate 接受参数 proto(一个对象或
尽管 OrdinaryObjectCreate 仅调用
抽象操作 OrdinaryCreateFromConstructor 接受参数 constructor(一个
抽象操作 GetPrototypeFromConstructor 接受参数 constructor(一个
抽象操作 RequireInternalSlot 接受参数 O(一个
ECMAScript
除了 [[Extensible]] 和 [[Prototype]] 外,ECMAScript
| 内部槽 | 类型 | 描述 |
|---|---|---|
| [[Environment]] |
一个 |
函数封闭的 |
| [[PrivateEnvironment]] |
一个 |
函数封闭的 |
| [[FormalParameters]] |
一个 |
定义函数正式参数列表的源文本的根解析节点。 |
| [[ECMAScriptCode]] |
一个 |
定义函数主体的源文本的根解析节点。 |
| [[ConstructorKind]] |
|
函数是否是派生类 |
| [[Realm]] |
一个 |
函数创建的 |
| [[ScriptOrModule]] |
一个 |
函数创建的脚本或模块。 |
| [[ThisMode]] |
|
定义 this 引用在函数的正式参数和代码体内如何被解释。this
指向词法上封闭函数的 |
| [[Strict]] | 一个布尔值 |
如果这是一个 |
| [[HomeObject]] | 一个对象 |
如果函数使用了 super,这是提供 [[GetPrototypeOf]] 的对象,从而开始
super 属性的查找。
|
| [[SourceText]] | 一系列 Unicode 码点 |
定义函数的 |
| [[Fields]] |
一个 |
如果函数是一个类,则这是一个列表,表示类的非静态字段及其对应的初始化器。 |
| [[PrivateMethods]] |
一个 |
如果函数是一个类,则这是一个列表,表示类的非静态私有方法和访问器。 |
| [[ClassFieldInitializerName]] |
一个字符串、一个符号、一个 |
如果函数作为类字段的初始化器创建,则用于 |
| [[IsClassConstructor]] | 一个布尔值 |
指示函数是否是一个类 |
所有 ECMAScript
ECMAScript
抽象操作 PrepareForOrdinaryCall 接受参数 F(一个 ECMAScript
抽象操作 OrdinaryCallBindThis 接受参数 F(一个 ECMAScript
语法驱动操作
尽管字段初始化器构成函数边界,调用
抽象操作 OrdinaryCallEvaluateBody 接受两个参数:F(一个 ECMAScript
ECMAScript
抽象操作 OrdinaryFunctionCreate 接受以下参数:functionPrototype(一个对象),
sourceText(一系列 Unicode 代码点),ParameterList(一个
抽象操作 AddRestrictedFunctionProperties 接受两个参数:F(一个
这个函数是 %ThrowTypeError% 内在对象。
它是一个匿名的内置
当调用时,它执行以下步骤:
这个函数的 [[Extensible]] 内部槽的值为
这个函数的
这个函数的
抽象操作 MakeConstructor 接受一个参数 F(一个 ECMAScript
抽象操作 MakeClassConstructor 接受一个参数 F(一个 ECMAScript
抽象操作 MakeMethod 接受参数 F(一个 ECMAScript
抽象操作 DefineMethodProperty 接受四个参数:homeObject(一个对象),key(一个
抽象操作 SetFunctionName 接受两个必需参数和一个可选参数:F(一个
抽象操作 SetFunctionLength 接受两个参数:F(一个
抽象操作 FunctionDeclarationInstantiation 接受两个参数:func(一个 ECMAScript
它在调用时执行以下步骤:
内置的
除了每个
内置
内置
内置
实现可以提供本规范中未定义的额外内置
内置
内置
抽象操作 BuiltinCallOrConstruct 接受以下参数:F(一个内置的
当 calleeContext 从
抽象操作 CreateBuiltinFunction 接受以下参数:behaviour(一个
本规范中定义的每个内置函数都是通过调用 CreateBuiltinFunction 抽象操作创建的。
本规范定义了几种内置的
一个对象是一个 绑定函数奇异对象,如果它的 [[Call]] 和(如果适用的话)[[Construct]] 内部方法使用以下实现,并且它的其他基本内部方法使用在
| 内部槽 | 类型 | 描述 |
|---|---|---|
| [[BoundTargetFunction]] | 可调用的对象 |
封装的 |
| [[BoundThis]] |
一个 |
在调用封装的函数时始终传递的 |
| [[BoundArguments]] |
一个 |
一个值的列表,其元素作为对封装函数的任何调用的第一个参数。 |
[[Call]] 内部方法用于一个
[[Construct]] 内部方法用于一个
抽象操作 BoundFunctionCreate 接受参数 targetFunction(一个
数组是一个
一个对象是一个 数组奇异对象(或简称为数组),如果它的 [[DefineOwnProperty]]
内部方法使用以下实现,并且它的其他基本内部方法使用在
[[DefineOwnProperty]] 内部方法在
抽象操作 ArrayCreate 接受参数 length(一个非负的
抽象操作 ArraySpeciesCreate 接受两个参数:originalArray(一个对象)和 length(一个非负的
抽象操作 ArraySetLength 接受两个参数:A(一个数组)和 Desc(一个
字符串对象是一个封装了字符串值的
如果一个对象的 [[GetOwnProperty]]、[[DefineOwnProperty]] 和 [[OwnPropertyKeys]] 内部方法使用以下实现,并且它的其他基本内部方法使用在
一个
一个
一个
抽象操作 StringCreate 接受两个参数:value(一个字符串)和 prototype(一个对象),并返回一个
抽象操作 StringGetOwnProperty 接受两个参数:S(一个具有 [[StringData]] 内部槽的对象)和
P(一个
大多数 ECMAScript 函数会向其代码提供一个 arguments 对象。根据函数定义的特性,其 arguments 对象可能是一个
如果一个对象的内部方法使用以下实现(未在此处指定的使用
虽然
Object.prototype.toString (
ParameterMap 对象及其属性值用作指定 arguments 对象与参数绑定之间对应关系的设备。ParameterMap 对象及其属性值并不直接从 ECMAScript 代码中可观察。ECMAScript 实现不需要实际创建或使用此类对象来实现指定的语义。
普通 arguments 对象定义了一个不可配置的
ECMAScript 对
[[GetOwnProperty]] 内部方法用于
[[DefineOwnProperty]] 内部方法用于
[[Get]] 内部方法用于
[[Set]] 内部方法用于
[[Delete]] 内部方法用于
抽象操作 CreateUnmappedArgumentsObject 接受一个参数 argumentsList(一个
抽象操作 CreateMappedArgumentsObject 接受参数 func(一个对象)、formals(一个
抽象操作 MakeArgGetter 接受参数 name(一个字符串)和 env(一个
抽象操作 MakeArgSetter 接受参数 name(一个字符串)和 env(一个
如果一个对象的 [[GetOwnProperty]]、[[HasProperty]]、[[DefineOwnProperty]]、[[Get]]、[[Set]]、[[Delete]] 和 [[OwnPropertyKeys]] 内部方法使用本节中的定义,并且其其他基本内部方法使用
[[GetOwnProperty]] 是
[[HasProperty]] 是
[[DefineOwnProperty]] 是
[[Get]] 是
[[Set]] 是
[[Delete]] 是
[[OwnPropertyKeys]] 是
一个 带缓冲见证记录的 TypedArray 是一个
带缓冲见证记录的 TypedArray 具有
| 字段名称 | 值 | 含义 |
|---|---|---|
| [[Object]] | 一个 |
其缓冲区的字节长度被加载的 |
| [[CachedBufferByteLength]] | 一个非负的 |
创建 |
抽象操作 MakeTypedArrayWithBufferWitnessRecord 接受参数 obj(一个
抽象操作 TypedArrayCreate 接受参数 prototype(一个对象),并返回一个
抽象操作 TypedArrayByteLength 接受参数 taRecord(一个
抽象操作 TypedArrayLength 接受参数 taRecord(一个
抽象操作 IsTypedArrayOutOfBounds 接受参数 taRecord(一个
抽象操作 IsValidIntegerIndex 接受参数 O(一个
抽象操作 TypedArrayGetElement 接受参数 O(一个
抽象操作 TypedArraySetElement 接受参数 O(一个
此操作似乎总是成功,但在尝试写入
抽象操作 IsArrayBufferViewOutOfBounds 接受参数 O(一个
一个 export * 语法间接导出的绑定。每个字符串值自身属性键是相应导出绑定名称的
一个对象是一个 模块命名空间特殊对象,如果它的 [[GetPrototypeOf]],
[[SetPrototypeOf]], [[IsExtensible]], [[PreventExtensions]], [[GetOwnProperty]], [[DefineOwnProperty]], [[HasProperty]], [[Get]], [[Set]], [[Delete]],
和
[[OwnPropertyKeys]] 内部方法使用本节中的定义,而它的其他基本内部方法使用
一个
一个
一个
一个
一个
一个
一个
一个
ResolveExport 是无副作用的。每次用特定的 exportName 和 resolveSet
参数调用此操作时,它必须返回相同的结果。实现可以选择预先计算或缓存每个
一个
一个
一个
抽象操作 ModuleNamespaceCreate 接收参数 module(一个
一个
如果对象的 [[SetPrototypeOf]] 内部方法使用以下实现,则该对象是一个 不可变原型特殊对象。(其其他基本内部方法可以根据具体的
与其他
一个
抽象操作 SetImmutablePrototype 接收参数 O(一个对象)和 V(一个对象或
代理对象是一个
如果对象的基本内部方法(包括 [[Call]] 和 [[Construct]],如果适用)使用本节中的定义,则该对象是一个 代理特殊对象。这些内部方法在
| 内部方法 | 处理程序方法 |
|---|---|
| [[GetPrototypeOf]] |
getPrototypeOf
|
| [[SetPrototypeOf]] |
setPrototypeOf
|
| [[IsExtensible]] |
isExtensible
|
| [[PreventExtensions]] |
preventExtensions
|
| [[GetOwnProperty]] |
getOwnPropertyDescriptor
|
| [[DefineOwnProperty]] |
defineProperty
|
| [[HasProperty]] |
has
|
| [[Get]] |
get
|
| [[Set]] |
set
|
| [[Delete]] |
deleteProperty
|
| [[OwnPropertyKeys]] |
ownKeys
|
| [[Call]] |
apply
|
| [[Construct]] |
construct
|
当调用处理程序方法来提供代理对象内部方法的实现时,处理程序方法会将代理的目标对象作为参数传递。代理的处理程序对象不一定具有与每个基本内部方法对应的方法。如果处理程序对象没有对应于内部陷阱的方法,则在代理上调用内部方法将导致调用代理目标对象上的相应内部方法。
代理对象的 [[ProxyHandler]] 和 [[ProxyTarget]]
内部插槽在对象创建时总是被初始化,并且通常不可修改。有些代理对象是以允许其随后被撤销的方式创建的。当代理被撤销时,其 [[ProxyHandler]]
和 [[ProxyTarget]] 内部插槽被设置为
由于代理对象允许内部方法的实现由任意 ECMAScript 代码提供,因此可能会定义一个其处理程序方法违反
在以下算法描述中,假设 O 是一个 ECMAScript 代理对象,P 是一个
[[GetPrototypeOf]] 内部方法的
Proxy 对象的 [[GetPrototypeOf]] 强制执行以下不变量:
[[SetPrototypeOf]] 内部方法的
Proxy 对象的 [[SetPrototypeOf]] 强制执行以下不变量:
[[IsExtensible]] 内部方法的
Proxy 对象的 [[IsExtensible]] 强制执行以下不变量:
[[PreventExtensions]] 内部方法的
Proxy 对象的 [[PreventExtensions]] 强制执行以下不变量:
[[GetOwnProperty]] 内部方法的
Proxy 对象的 [[GetOwnProperty]] 强制执行以下不变量:
[[DefineOwnProperty]] 内部方法的
Proxy 对象的 [[DefineOwnProperty]] 强制执行以下不变量:
[[HasProperty]] 内部方法的
Proxy 对象的 [[HasProperty]] 强制执行以下不变量:
[[Get]] 内部方法的
[[Set]] 内部方法的
[[Delete]] 内部方法的
Proxy 对象的 [[Delete]] 强制执行以下不变量:
[[OwnPropertyKeys]] 内部方法的
[[Call]] 内部方法用于
[[Construct]] 内部方法用于
[[Construct]] 对于 Proxy 对象强制执行以下不变量:
抽象操作 ValidateNonRevokedProxy 接受参数 proxy(一个
抽象操作 ProxyCreate 接受参数 target(一个
ECMAScript 源代码 是一系列 Unicode 代码点。在 ECMAScript 语法允许的地方,所有从 U+0000 到 U+10FFFF 的 Unicode
代码点值,包括代理代码点,都可以出现在 ECMAScript 源代码中。用于存储和交换 ECMAScript 源代码的实际编码与本规范无关。不论外部源代码编码如何,符合规范的 ECMAScript
实现都将源代码处理为等效的
组合字符序列的组成部分被视为单独的 Unicode 代码点,即使用户可能将整个序列视为一个字符。
在字符串字面量、正则表达式字面量、模板字面量和标识符中,任何 Unicode 代码点也可以使用 Unicode 转义序列来表示,显式表达代码点的数值。在注释中,这样的转义序列实际上被忽略,作为注释的一部分。
ECMAScript 与 Java 编程语言在 Unicode 转义序列的行为上有所不同。例如,在 Java 程序中,如果 Unicode 转义序列 \u000A
出现在单行注释中,它会被解释为行终止符(Unicode 代码点 U+000A 是换行符(LF)),因此下一个代码点不再是注释的一部分。同样,如果 Unicode 转义序列 \u000A
出现在 Java 程序的字符串字面量中,它也会被解释为行终止符,字符串字面量中不允许有行终止符——必须写成 \n 而不是
\u000A,以使换行符(LF)成为字符串字面量的字符串值的一部分。在 ECMAScript 程序中,出现在注释中的 Unicode 转义序列从不被解释,因此不能终止注释。同样,出现在
ECMAScript 程序的字符串字面量中的 Unicode 转义序列始终是字面量的一部分,永远不会被解释为行终止符或可能终止字符串字面量的代码点。
抽象操作 UTF16EncodeCodePoint 接受参数 cp(一个 Unicode 代码点)并返回一个字符串。调用时,它执行以下步骤:
抽象操作 CodePointsToString 接受参数 text(一个 Unicode 代码点序列)并返回一个字符串。它将 text 转换为字符串值,如
抽象操作 UTF16SurrogatePairToCodePoint 接受参数 lead(一个代码单元)和 trail(一个代码单元),并返回一个代码点。形成
UTF-16
抽象操作 CodePointAt 接受参数 string(一个字符串)和 position(一个非负
抽象操作 StringToCodePoints 接受参数 string(一个字符串)并返回一个代码点的
抽象操作 ParseText 接受参数 sourceText(一个 Unicode 代码点序列)和 goalSymbol(ECMAScript
语法中的一个非终结符)并返回一个
另见第
有四种类型的 ECMAScript 代码:
eval 函数的源文本。更准确地说,如果传递给内建 eval 函数的参数
eval 的 eval code 是该 Function code 通常以函数定义的主体形式提供(
将
指令序言 是出现在
"use strict" 指令 是出现在
"use strict" 或 'use strict'。
ECMAScript 语法单元可以使用无限制或严格模式语法和语义进行处理
(
eval 是包含在严格模式代码中的 不是严格模式代码的 ECMAScript 代码称为 非严格代码。
ECMAScript 实现可能支持对函数
ECMAScript
在多个情况下,词法输入元素的识别对消耗输入元素的语法语境是敏感的。这需要词法语法的多个
Unicode 格式控制字符(即 Unicode 字符数据库中类别为 “Cf” 的字符,如左到右标记或右到左标记)是用于在缺乏高级协议(如标记语言)的情况下控制一段文本格式的控制代码。
允许在源文本中使用格式控制字符以便于编辑和显示是很有用的。所有格式控制字符都可以在注释、字符串字面量、模板字面量和正则表达式字面量中使用。
U+200C(零宽非连接符)和 U+200D(零宽连接符)是用于在某些语言中形成单词或短语时进行必要区分的格式控制字符。在
U+FEFF(零宽不换行空格)是主要用于文本开头的格式控制字符,用来标记它为 Unicode 并允许检测文本的编码和字节顺序。出于这种目的而使用的 <ZWNBSP>
字符有时也会出现在文本的开头之后,例如由于文件连接的结果。在
某些格式控制字符在注释、字符串字面量和正则表达式字面量之外的特殊处理在
| 代码点 | 名称 | 缩写 | 用法 |
|---|---|---|---|
U+200C
|
零宽非连接符 | <ZWNJ> |
|
U+200D
|
零宽连接符 | <ZWJ> |
|
U+FEFF
|
零宽不换行空格 | <ZWNBSP> |
|
空白符代码点用于提高源文本的可读性,并将词法单元(不可分割的词法单位)彼此分开,但除此之外没有其他意义。空白符代码点可以出现在任意两个词法单元之间,以及输入的开头或结尾。空白符代码点可以出现在
ECMAScript 的空白符代码点列在
| 代码点 | 名称 | 缩写 |
|---|---|---|
U+0009 |
CHARACTER TABULATION | <TAB> |
U+000B |
LINE TABULATION | <VT> |
U+000C |
FORM FEED (FF) | <FF> |
U+FEFF |
ZERO WIDTH NO-BREAK SPACE | <ZWNBSP> |
| general category 中的任意代码点 “Space_Separator” | <USP> |
U+0020 (SPACE) 和 U+00A0 (NO-BREAK SPACE) 代码点是 <USP> 的一部分。
除了表
像空白符代码点一样,行终止符代码点用于提高源文本的可读性,并将词法单元(不可分割的词法单位)彼此分开。然而,与空白符代码点不同,行终止符对语法规则的行为有一定影响。通常,行终止符可以出现在任意两个词法单元之间,但在某些地方,语法规则禁止它们的出现。行终止符还会影响自动分号插入的过程(
行终止符可以出现在
行终止符包含在正则表达式中的 \s 类匹配的空白符代码点集合中。
ECMAScript 行终止符代码点列在
| 代码点 | Unicode 名称 | 缩写 |
|---|---|---|
U+000A |
LINE FEED (LF) | <LF> |
U+000D |
CARRIAGE RETURN (CR) | <CR> |
U+2028 |
LINE SEPARATOR | <LS> |
U+2029 |
PARAGRAPH SEPARATOR | <PS> |
只有表
注释可以是单行或多行。多行注释不能嵌套。
由于单行注释可以包含任何 Unicode 代码点,除了 // 标记到行尾的所有代码点组成。然而,行尾的
注释表现得像空白符,并被丢弃,除了如果一个
本节中的一些规则在
Hashbang 注释是位置敏感的,并且像其他类型的注释一样,从语法解析的输入元素流中被丢弃。
本标准指定了特定的代码点添加:U+0024 (美元符号) 和 U+005F (下划线) 在
非终结符
_。
具有 Unicode 属性 “ID_Start” 和 “ID_Continue” 的代码点集合分别包括具有 Unicode 属性 “Other_ID_Start” 和 “Other_ID_Continue” 的代码点。
在 \ 不贡献任何代码点。Unicode 转义序列不能用于对
根据 Unicode 标准,两个规范等效的
语法导向操作
语法导向操作
关键字 是一个与
if、while、async、await 等。
保留字 是一个不能用作标识符的
if 和 while 是保留字,await
仅在异步函数和模块中是保留的,而 async 不是保留的,它可以在变量名或语句标签中使用。
本规范使用语法生成式和
await 和 yield,都是无条件保留的。await 和 yield 的例外情况在
那些始终允许作为标识符使用的,不是关键字的名称,例如 Math、window、toString 和
_;
那些永远不允许作为标识符使用的名称,即下面列出的 await 和
yield);
那些在特定上下文中允许作为标识符使用的名称,即 await 和 yield;
那些在 let、static、implements、interface、package、private、protected
和 public;
那些始终允许作为标识符使用,但在某些语法生成式中的某些地方也出现为关键字的名称,即 as、async、from、get、meta、of、set
和 target。
术语 条件关键字 或 上下文关键字 有时用来指在上述最后三类中的关键字,这些关键字可以在某些上下文中作为标识符使用,而在其他上下文中作为关键字使用。
根据
\ Unicode 转义序列表示。
\
els\u{65} 来声明一个名为 "else" 的变量。
enum 目前在本规范中不作为关键字使用。它是一个 未来保留字,为将来的语言扩展预留。
同样,implements、interface、package、private、protected
和 public 在
紧跟在
例如:3in 是错误的,而不是两个输入元素 3 和 in。
数值字面量表示
字符串字面量是用单引号或双引号括起来的 0 个或更多 Unicode 代码点。Unicode 代码点也可以通过转义序列表示。除了闭合引号的代码点、U+005C(反斜杠)、U+000D(回车符)和
U+000A(换行符)外,所有代码点都可以直接出现在字符串字面量中。任何代码点都可以以转义序列的形式出现。字符串字面量求值为 ECMAScript 字符串值。在生成这些字符串值时,Unicode 代码点按照
非终结符
<LF> 和 <CR> 不能出现在字符串字面量中,除非作为 \n 或 \u000A。
字符串字面量表示
| 转义序列 | 代码单元值 | Unicode 字符名称 | 符号 |
|---|---|---|---|
\b |
0x0008 |
退格符 | <BS> |
\t |
0x0009 |
字符制表符 | <HT> |
\n |
0x000A |
换行符 (LF) | <LF> |
\v |
0x000B |
行制表符 | <VT> |
\f |
0x000C |
换页符 (FF) | <FF> |
\r |
0x000D |
回车符 (CR) | <CR> |
\" |
0x0022 |
引号 | " |
\' |
0x0027 |
撇号 | ' |
\\ |
0x005C |
反斜杠 | \ |
下面的生成式描述了正则表达式字面量的语法,并由输入元素扫描器用于查找正则表达式字面量的结束位置。包含
实现可以扩展
正则表达式字面量不能为空;而不是表示一个空的正则表达式字面量,代码单元序列 // 启动一个单行注释。要指定一个空的正则表达式,请使用:/(?:)/。
大多数 ECMAScript 语句和声明必须以分号结尾。这些分号总是可以显式出现在源代码中。然而,为了方便,在某些情况下,这些分号可以从源代码中省略。在这些情况下,可以通过描述分号自动插入到源代码令牌流中的那些情况来解释。
在以下规则中,“令牌”是指使用当前词法
分号插入有三条基本规则:
当从左到右解析源文本时,遇到不允许的令牌(称为冒犯令牌)时,如果以下条件之一为真, 则会在冒犯令牌之前自动插入分号:
但是,前述规则有一个额外的优先条件:如果分号将被解析为空语句或成为for语句头中的两个分号之一,
则不会自动插入分号(见
以下是语法中唯一的受限规则:
这些受限规则的实际效果如下:
++或--令牌且解析器将其视为后缀操作符,并且前一个令牌与++
或--令牌之间至少有一个++或--令牌之前自动插入分号。
continue、break、return、throw或
yield令牌并且在下一个令牌之前遇到一个continue、break、return、throw或
yield令牌之后自动插入分号。
=>
令牌之前时,自动插入分号并且标点符号会导致语法错误。
async令牌之后有一个function或(令牌之前时,自动插入分号并且async令牌不会被视为与后续令牌相同的表达式或类元素。
async令牌之后有一个*令牌之前时,自动插入分号并且标点符号会导致语法错误。
因此,对ECMAScript程序员的实际建议是:
以下源代码
{ 1 2 } 3
即使使用自动分号插入规则,也不是 ECMAScript 语法中的有效句子。相反,以下源代码
{ 1
2 } 3
也不是有效的 ECMAScript 句子,但通过自动分号插入会被转换为以下内容:
{ 1
;2 ;} 3;
这是一个有效的 ECMAScript 句子。
以下源代码
for (a; b
)
不是有效的 ECMAScript 句子,且不会因自动分号插入而改变,因为 for 语句头部需要的分号。自动分号插入永远不会插入 for 语句头部的两个分号之一。
以下源代码
return
a + b
通过自动分号插入会被转换为以下内容:
return;
a + b;
表达式 a + b 不会被视为 return 语句要返回的值,因为 return 与 a + b
之间有一个
以下源代码
a = b
++c
通过自动分号插入会被转换为以下内容:
a = b;
++c;
符号 ++ 不会被视为应用于变量 b 的后缀运算符,因为 b 与 ++ 之间有一个
以下源代码
if (a > b)
else c = d
不是有效的 ECMAScript 句子,且即使在 else 符号之前没有任何语法规则适用,自动分号插入也不会改变,因为自动插入的分号会被解析为一个空语句。
以下源代码
a = b + c
(d + e).print()
不会被自动分号插入规则改变,因为第二行开始的括号表达式可以被解释为函数调用的参数列表:
a = b + c(d + e).print()
在赋值语句必须以左括号开始的情况下,程序员最好在前一条语句的末尾提供一个显式分号,而不是依赖自动分号插入。
ECMAScript 程序可以通过依赖自动分号插入来以很少分号的风格编写。如上所述,分号并不会在每个换行处插入,自动分号插入可能依赖跨行终止符的多个标记。
随着新的语法特性被添加到 ECMAScript 中,可能会增加一些语法产生式,这会导致依赖自动分号插入的行在解析时改变语法产生式。
在本节的目的中,如果某个地方的分号是否插入取决于之前的源文本,则该自动分号插入的案例被认为是有趣的。本节的其余部分描述了 ECMAScript 这一版本中一些有趣的自动分号插入案例。
在一个
()。没有分号,这两行会被视为一个 [)。没有分号,这两行会被视为属性访问,而不是一个 `)。没有分号,这两行会被解释为一个标记模板 (+ 或 -。没有分号,这两行会被解释为使用对应的二元运算符。/ ECMAScript 包含一些语法产生式,它们包括“[无
本节的其余部分描述了 ECMAScript 这一版本中使用“[无
yield 和 await 在语法中允许作为
let
await 0;
yield 或 await,那么这是一个语法错误。
评估
在 yield
可以用作标识符。评估 yield 解析为
当处理如下产生式实例时
对
this 关键字关于
false,返回 true,返回 数组元素可以在元素列表的开头、中间或结尾省略。每当元素列表中的逗号前没有
对象初始化器是一个描述对象初始化的表达式,写成类似字面量的形式。它是一个由零个或多个
在某些上下文中,
除了描述实际的对象初始化器外,
此生产的存在是为了使
由
参见
参见
参见
参见
抽象操作IsValidRegularExpressionLiteral接受参数literal(一个
d、g、i、m、s、u、v或y之外的任何代码点,或flags包含的任何代码点不止一次,则返回u,则令u为v,则令v为模板字符串是一个
抽象操作 TemplateString 接受参数 templateToken(一个
如果 raw 是
抽象操作 GetTemplateObject 接受参数 templateLiteral(一个
模板对象的创建不会导致
程序代码中的每个
本规范的未来版本可能会定义模板对象的附加不可枚举属性。
SubstitutionEvaluation 是一个
String.prototype.concat 而不是 + 运算符。
String.prototype.concat 而不是 + 运算符。
String.prototype.concat 而不是 + 运算符。
此算法不会对 delete 和 typeof 等运算符应用于带括号的表达式。
当处理以下产生式的一个实例时
此产生式存在是为了防止自动分号插入规则(
a?.b
`c`
以便将其解释为两个有效的语句。目的是保持与没有可选链的类似代码的一致性:
a.b
`c`
这是一个有效的语句,并且自动分号插入不适用。
属性通过名称访问,使用点表示法:
或方括号表示法:
点表示法通过以下句法转换解释:
其行为与以下相同:
同样地:
其行为与以下相同:
其中 <identifier-name-string> 是评估
抽象操作 EvaluatePropertyAccessWithExpressionKey 接受参数 baseValue(一个
抽象操作 EvaluatePropertyAccessWithIdentifierKey 接受参数 baseValue(一个
new Operator抽象操作 EvaluateNew 接受参数 constructExpr(一个
一个
抽象操作 EvaluateCall 接受参数 func(一个
super 关键字抽象操作 GetSuperConstructor 不接受任何参数,并返回一个
抽象操作 MakeSuperPropertyReference 接受参数 actualThis(一个
参数列表的评估产生一个
语法导向操作
?.标记开始。语法导向操作
抽象操作ContinueDynamicImport接受参数promiseCapability(一个import()
标签模板是一个函数调用,其中调用的参数是从一个
The import.meta 返回的对象。
HostGetImportMetaProperties 的默认实现是返回一个新的空
The import.meta
返回的对象。
大多数
HostFinalizeImportMeta 的默认实现是返回
delete 运算符
如果派生的
并且
最后一项规则意味着表达式如 delete (((foo))) 会产生
当 delete 运算符出现在 delete 运算符出现在
void 运算符typeof 运算符+ 运算符一元 + 运算符将其操作数转换为
- 运算符一元 - 运算符将其操作数转换为数值,然后对其取反。取反
~ )! )* 执行乘法,生成其操作数的乘积。/ 执行除法,生成其操作数的商。% 生成其操作数在隐式除法中的余数。+ )加法运算符既可以执行字符串连接,也可以执行数值加法。
- )减法运算符执行减法,生成其操作数的差值。
<< )对左操作数执行按位左移操作,移动的位数由右操作数指定。
>> )对左操作数执行按位右移操作,移动的位数由右操作数指定,并使用符号位填充空出的位。
>>> )对左操作数执行按位右移操作,移动的位数由右操作数指定,并使用零填充空出的位。
关系运算符的求值结果总是布尔类型,反映运算符命名的关系是否在其两个操作数之间成立。
[In] 语法参数是为了避免在关系表达式中混淆 in 运算符和 for 语句中的 in 运算符。
抽象操作 InstanceofOperator 接受参数 V(一个
步骤
instanceof 运算符语义。如果对象没有定义或继承
instanceof 语义。
等值运算符的求值结果总是布尔类型,反映运算符命名的关系是否在其两个操作数之间成立。
根据上述等值定义:
`${a}` == `${b}` 强制进行。
+a == +b 强制进行。
!a == !b 强制进行。
等值运算符保持以下不变量:
A != B 等价于 !(A == B)。
A == B 等价于 B == A,除了 A 和 B 的求值顺序。
等值运算符并不总是传递的。例如,可能存在两个不同的字符串对象,每个对象表示相同的字符串值;每个字符串对象会被 == 运算符视为与字符串值相等,但这两个字符串对象彼此并不相等。例如:
new String("a") == "a" 和 "a" == new String("a") 均为 new String("a") == new String("a") 为 字符串比较使用简单的代码单元值相等测试。不会尝试使用 Unicode 规范中定义的更复杂的、语义导向的字符或字符串相等性定义和排序顺序。因此,根据 Unicode 标准规范等价的字符串值可能会被测试为不相等。实际上,这个算法假设两个字符串都已处于规范化形式。
由 && 或 || 运算符生成的值不一定是布尔类型。生成的值始终是两个操作数表达式之一的值。
? :)
ECMAScript 中
如果
如果
| assignmentOpText | opText |
|---|---|
**= |
** |
*= |
* |
/= |
/ |
%= |
% |
+= |
+ |
-= |
- |
<<= |
<< |
>>= |
>> |
>>>= |
>>> |
&= |
& |
^= |
^ |
|= |
| |
抽象操作 ApplyStringOrNumericBinaryOperator 接受参数 lval(一个 **、*、/、%、+、-、<<、>>、>>>、&、^
或 |)和 rval(一个
+,则
**,返回 ? /,返回 ? %,返回 ? >>>,返回
? | opText | |
operation |
|---|---|---|
** |
Number | |
* |
Number | |
* |
BigInt | |
/ |
Number | |
% |
Number | |
+ |
Number | |
+ |
BigInt | |
- |
Number | |
- |
BigInt | |
<< |
Number | |
<< |
BigInt | |
>> |
Number | |
>> |
BigInt | |
>>> |
Number | |
& |
Number | |
& |
BigInt | |
^ |
Number | |
^ |
BigInt | |
| |
Number | |
| |
BigInt | |
在步骤
步骤
抽象操作 EvaluateStringOrNumericBinaryExpression 接受参数 leftOperand(一个
在处理以下产生式的实例时
对于
如果
如果
语法指导操作
语法指导操作
语法指导操作
从左到右的求值顺序通过在访问迭代器或求值
,)
无论控制如何离开
eval 函数的调用都返回值 1:
eval("1;;;;;")
eval("1;{}")
eval("1;var a;")
抽象操作 BlockDeclarationInstantiation 接受参数 code(一个
当调用时,它执行以下步骤:
let 和 const 声明定义的变量作用域为 let 声明中的
一个 const 声明中。
一个 var 语句声明的变量作用域为
如果一个
属性绑定初始化是一个
剩余绑定初始化是一个
键绑定初始化是一个
它在以下产生式上分段定义:
一个 function 或 class async function 开始,因为这可能会使其与一个 let [ 开始,因为这可能会使其与一个 let
if 语句else] 以通常的方式解决了经典的“悬空 else”问题。也就是说,当关联的
if 选择不明确时,else 与最近的(最内层的)候选 if 相关联。
只有在实现
抽象操作 LoopContinues 接受参数 completion(一个
在
语法导向操作 LoopEvaluation 接受参数 labelSet(一个
do-while 语句只有在实现
语法导向操作 DoWhileLoopEvaluation 接受参数 labelSet(一个
while 语句只有在实现
语法导向操作 WhileLoopEvaluation 接受参数 labelSet(一个
for 语句只有在实现
语法导向操作 ForLoopEvaluation 接受参数 labelSet(一个
抽象操作 ForBodyEvaluation 接受参数 test(一个
抽象操作 CreatePerIterationEnvironment 接受参数 perIterationBindings
(一个
for-in、for-of 和
for-await-of 语句
本节由附录
只有在实现
如果
如果
语法导向操作 IsDestructuring 不接受参数并返回一个布尔值。它在以下产生式上定义:
本节由附录
语法导向操作 ForDeclarationBindingInitialization 接受参数 value(一个
它在以下产生式上定义:
语法导向操作 ForDeclarationBindingInstantiation 接受参数 environment(一个
语法导向操作 ForInOfLoopEvaluation 接受参数 labelSet(一个
本节由附录
抽象操作 ForIn/OfHeadEvaluation 接受参数 uninitializedBoundNames(一个
抽象操作 ForIn/OfBodyEvaluation 接受参数 lhs(一个
抽象操作 EnumerateObjectProperties 接受参数 O(一个对象)并返回一个迭代器。它在调用时执行以下步骤:
next 方法遍历 O 的所有可枚举的字符串键属性。迭代器对象对 ECMAScript
代码永远不可直接访问。遍历属性的机制和顺序未指定,但必须符合以下规则。
迭代器的 throw 和 return 方法是 next 方法处理对象属性以确定属性键是否应作为迭代器值返回。返回的属性键不包括 Symbols。目标对象的属性可能在枚举期间被删除。在迭代器的 next
方法处理之前删除的属性将被忽略。如果在枚举期间向目标对象添加新属性,则不能保证新添加的属性会在活动枚举中被处理。一个属性名在任何枚举中最多由迭代器的 next 方法返回一次。
枚举目标对象的属性包括枚举其原型及其原型的原型等的属性,递归地;但如果原型的属性与迭代器的 next 方法已经处理的属性同名,则不处理原型的属性。原型对象的可枚举属性名必须通过调用
EnumerateObjectProperties 并将原型对象作为参数来获取。EnumerateObjectProperties 必须通过调用目标对象的 [[OwnPropertyKeys]] 内部方法来获取目标对象的自有属性键。目标对象的属性属性必须通过调用其 [[GetOwnProperty]] 内部方法来获取。
此外,如果 O 或其原型链中的任何对象不是
ECMAScript 实现不需要直接实现
以下是一个符合这些规则的 ECMAScript 生成器函数的非正式定义:
function* EnumerateObjectProperties(obj) {
const visited = new Set();
for (const key of Reflect.ownKeys(obj)) {
if (typeof key === "symbol") continue;
const desc = Reflect.getOwnPropertyDescriptor(obj, key);
if (desc) {
visited.add(key);
if (desc.enumerable) yield key;
}
}
const proto = Reflect.getPrototypeOf(obj);
if (proto === null) return;
for (const protoKey of EnumerateObjectProperties(proto)) {
if (!visited.has(protoKey)) yield protoKey;
}
}
For-In 迭代器是表示特定对象上的特定迭代的对象。For-In 迭代器对象永远不会直接对 ECMAScript 代码可访问;它们仅存在于阐明
抽象操作 CreateForInIterator 接受参数 object(一个对象)并返回一个 For-In 迭代器。它用于创建一个 For-In 迭代器对象,该对象按特定顺序迭代 object 的自身和继承的可枚举字符串属性。调用时执行以下步骤:
%ForInIteratorPrototype% 对象:
For-In 迭代器实例是
continue 语句static 初始化块边界),则是语法错误。
break 语句static 初始化块边界),则是语法错误。
return 语句
return 语句会导致函数停止执行,并在大多数情况下返回一个值给调用者。如果省略了
return 语句可能实际上不会返回值给调用者。例如,在
try 块中,return 语句的
finally 块时被另一个
with 语句
with 语句为计算对象添加了一个
仅在实现
switch 语句
抽象操作 CaseClauseIsSelected 接受参数 C(一个
此操作不执行 C 的
无论控制如何离开
一个 break和continue语句结合使用。ECMAScript
没有goto语句。
一个
如果实现了
抽象操作 IsLabelledFunction 接受参数 stmt (一个
一个
try 语句包含可能发生异常的代码块,如运行时错误或 throw 语句。catch 子句提供异常处理代码。当 catch 子句捕获异常时,其
对于此生成规则的替代静态语义定义,见
CatchClauseEvaluation 是一个带有参数 thrownValue(一个 ECMAScript 语言值)的语法直接操作,返回一个包含 ECMAScript 语言值的正常完成记录或一个中断完成记录。它在以下生成规则中定义:
无论控制如何离开
debugger 语句执行
各种 ECMAScript 语言元素会导致创建 ECMAScript
在
匿名的 export default 声明的一部分出现,因此其函数代码始终是
替代语义见
使用
处理生产式的实例时
arguments,super,this 或 new.target
的本地绑定。在
arguments,super,this 或 new.target
的任何引用必须解析为词法上封闭的环境中的绑定。通常,这将是紧密封闭函数的函数环境。即使
super 的引用,在步骤
super 的
super 所需的状态可以通过
语法指向操作 HasDirectSuper 不接受任何参数并返回一个布尔值。它在以下生成式上逐段定义:
语法指向操作 SpecialMethod 不接受任何参数并返回一个布尔值。它在以下生成式上逐段定义:
语法指向操作 DefineMethod 接受参数 object(一个对象)和可选参数 functionPrototype(一个对象),并返回一个包含字段 [[Key]](一个属性键)和 [[Closure]](一个 ECMAScript 函数对象)的 Record 的正常完成,或一个中断完成。它在以下生成式上逐段定义:
语法指向操作 MethodDefinitionEvaluation 接受参数 object(一个对象)和 enumerable(一个布尔值),并返回包含一个 PrivateElement 或 unused 的正常完成,或一个中断完成。它在以下生成式上逐段定义:
紧接在 yield 之后的语法上下文要求使用
语法导向操作
语法导向操作
匿名的 export default 声明的一部分出现,因此其函数代码始终是
throw
方法抛出的异常会被传播。throw 方法的正常完成与 next 类似。
匿名的
export default 声明的一部分出现。
在
类定义总是
如果
await 为 早期错误规则确保只有一个名为
本规范中未列出的每个语法生成式替代项隐含有以下默认的 AllPrivateIdentifiersValid 定义:
本规范中未列出的每个语法生成式替代方案隐式具有以下 ContainsArguments 的默认定义:
为了方便规范,私有方法和访问器与私有字段一起包含在类实例的 [[PrivateElements]] 插槽中。然而,任何给定对象都具有某个类定义的所有或无任何私有方法和访问器。此功能的设计使得实现可以选择使用不需要单独跟踪每个方法或访问器的策略来实现私有方法和访问器。
例如,实现可以直接将实例私有方法与相应的 this 值运行。然后在对象上查找实例私有方法的过程是检查定义该方法的类
这与私有字段不同:因为字段初始化程序在类实例化期间可能会抛出异常,个别对象可能具有给定类的某些私有字段的子集,因此一般需要单独跟踪私有字段。
其分段定义如下生产:
constructor(...args) { super(...args); }。最显著的区别在于,虽然前述的
%Array.prototype% 上的
constructor() {}。
当 [Await] 参数存在时,await 作为
不同于
当处理以下生成式的一个实例时
对
抽象操作 IsInTailPosition 接受参数 call(一个
它的定义依赖于以下几种产生式:
抽象操作 PrepareForTailCall 不接受任何参数,并返回
尾位置调用必须在调用目标函数之前释放当前执行函数的任何瞬态内部资源
例如,尾位置调用应该仅在目标函数的激活记录的大小超出调用函数的激活记录大小时,才增加实现的激活记录栈的大小。如果目标函数的激活记录更小,则栈的总大小应减少。
super,除非包含 super 的源文本是由 super 在 语法导向操作
脚本记录 封装了有关正在评估的脚本的信息。每个脚本记录包含了
| 字段名称 | 值类型 | 含义 |
|---|---|---|
| [[Realm]] | 一个 |
此脚本创建时所在的 |
| [[ECMAScriptCode]] | 一个 |
解析此脚本的源文本后的结果。 |
| [[LoadedModules]] | 一个 |
从此脚本导入的规范符字符串到解析的 |
| [[HostDefined]] | 任何东西(默认值为 |
供 |
抽象操作 ParseScript 接受以下参数:sourceText(
实现可以在对脚本源文本进行 ParseScript 之前解析脚本源文本并分析其早期错误条件。然而,任何错误的报告必须推迟到本规范实际对该源文本执行 ParseScript 的时候。
抽象操作 ScriptEvaluation 接受一个参数 scriptRecord(一个
抽象操作 GlobalDeclarationInstantiation 接受两个参数:script(一个
在为脚本评估建立执行上下文时,声明会在当前全局环境中被实例化。代码中声明的每个全局绑定都会被实例化。
调用时执行以下步骤:
与显式的 var 或函数声明不同,直接在
super,则为语法错误。
重复的 export default
抽象操作 ImportedLocalNames 接受参数 importEntries(一个
ModuleRequests 是一个
一个 模块记录 封装了单个模块的导入和导出的结构信息。这些信息用于链接一组连接模块的导入和导出。模块记录包括四个字段,这些字段仅在评估模块时使用。
为了规范目的,模块记录值是
模块记录定义了
| 字段名称 | 值类型 | 含义 |
|---|---|---|
| [[Realm]] | 一个 |
创建此模块的 |
| [[Environment]] | 一个 |
包含此模块顶级绑定的 |
| [[Namespace]] | 一个对象或 |
如果为此模块创建了一个模块命名空间对象 ( |
| [[HostDefined]] | 任何类型(默认值为 |
保留字段,供需要将附加信息与模块关联的 |
| 方法 | 目的 |
|---|---|
| LoadRequestedModules( [ hostDefined ] ) |
通过递归加载所有依赖项来准备模块进行链接,并返回一个承诺。 |
| GetExportedNames([exportStarSet]) |
返回从此模块直接或间接导出的所有名称的列表。 在调用此方法之前,LoadRequestedModules 必须成功完成。 |
| ResolveExport(exportName [, resolveSet]) |
返回此模块导出的名称的绑定。绑定由 ResolvedBinding Record 表示,形式为 { [[Module]]:
每次使用特定的 exportName 和 resolveSet 对调用此操作时,必须返回相同的结果。 在调用此方法之前,LoadRequestedModules 必须成功完成。 |
| Link() |
通过传递解决所有模块依赖项并创建一个 在调用此方法之前,LoadRequestedModules 必须成功完成。 |
| Evaluate() |
返回此模块及其依赖项评估的承诺,成功评估或已成功评估时解析,评估错误或已失败评估时拒绝。如果承诺被拒绝, 在调用此方法之前,Link 必须成功完成。 |
一个 循环模块记录
用于表示关于一个模块的信息,该模块可以与其他
除了在
| 字段名称 | 值类型 | 含义 |
|---|---|---|
| [[Status]] | 最初为 |
|
| [[EvaluationError]] | 一个 |
一个 |
| [[DFSIndex]] | 一个 |
仅在链接和评估期间使用的辅助字段。如果 [[Status]] 是 |
| [[DFSAncestorIndex]] | 一个 |
仅在链接和评估期间使用的辅助字段。如果 [[Status]] 是 |
| [[RequestedModules]] | 一个 |
一个 |
| [[LoadedModules]] |
一个 |
一个从此记录表示的模块使用的指定符字符串到解析的 |
| [[CycleRoot]] |
一个 |
循环中第一个访问的模块,强连通分量的根 DFS 祖先。对于不在循环中的模块,这将是模块本身。一旦 Evaluate 完成,模块的 [[DFSAncestorIndex]] 是其 [[CycleRoot]] 的 [[DFSIndex]]。 |
| [[HasTLA]] | 一个布尔值 | 此模块是否是单独异步的(例如,如果它是一个包含顶层 await 的 |
| [[AsyncEvaluation]] | 一个布尔值 | 此模块是否本身是异步的或有异步依赖。注意:此字段设置的顺序用于排序排队执行,参见 |
| [[TopLevelCapability]] | 一个 |
如果此模块是某个循环的 [[CycleRoot]],并且在那个循环中的某个模块上调用了 Evaluate(),此字段包含整个评估的
|
| [[AsyncParentModules]] | 一个 |
如果此模块或其依赖项有 [[HasTLA]] 为
|
| [[PendingAsyncDependencies]] | 一个 |
如果此模块有任何异步依赖项,这会跟踪此模块剩余的异步依赖模块数量。具有异步依赖项的模块将在此字段达到 0 且没有执行错误时执行。 |
除了在
| 方法 | 目的 |
|---|---|
| InitializeEnvironment() | 初始化模块的 |
| ExecuteModule( [ promiseCapability ] ) | 在其 |
一个 GraphLoadingState Record 是一个
| 字段名称 | 值类型 | 含义 |
|---|---|---|
| [[PromiseCapability]] | 一个 |
加载过程完成时解析的承诺。 |
| [[IsLoading]] | 一个布尔值 | 如果加载过程尚未完成(无论成功还是出错),则为 true。 |
| [[PendingModulesCount]] | 一个非负的 |
跟踪待处理的 |
| [[Visited]] | 一个 |
当前加载过程中已加载的 |
| [[HostDefined]] | 任何类型(默认值为 |
包含从 LoadRequestedModules 调用者传递到 |
LoadRequestedModules 的具体方法来自
<link rel="preload" as="..."> 标签的正确获取目标。import() 表达式从不设置
hostDefined 参数。
抽象操作 InnerModuleLoading 接受 state(一个
抽象操作 ContinueModuleLoading 接受 state(一个
一个
抽象操作 InnerModuleLinking 接受参数module(一个
module 的
抽象操作 InnerModuleEvaluation 接受参数 module(一个
模块在被 InnerModuleEvaluation 遍历时处于
当一个异步循环中的模块不处于
抽象操作 ExecuteAsyncModule 接受参数 module(一个
抽象操作 GatherAvailableAncestors 接受参数 module(一个
当根 module 的异步执行完成时,此函数确定能够同步执行的模块列表,并将它们填充到 execList 中。
抽象操作 AsyncModuleExecutionFulfilled 接受参数 module(一个
抽象操作 AsyncModuleExecutionRejected 接受参数 module(一个
本非规范性章节提供了一系列常见模块图的链接和评估示例,特别关注错误发生的方式。
首先考虑以下简单模块图:
我们首先假设没有错误条件。当一个
然后考虑涉及链接错误的情况,在成功调用A.LoadRequestedModules()之后。如果
最后,考虑在成功调用Link()后发生评估错误的情况。如果
现在考虑一种不同类型的错误条件:
在这种情况下,模块A声明依赖于某个其他模块,但没有该模块的
这里加载、链接和评估错误之间的区别在于以下特征:
现在,考虑一个有循环的模块图:
在这里,我们假设入口点是模块A,因此
然后
在循环模块图的评估阶段的成功案例中,类似的过程也会发生。
现在考虑A有一个链接错误的情况;例如,它尝试从C导入一个不存在的绑定。在这种情况下,上述步骤仍然会发生,包括对A的第二次
或者,考虑A有一个评估错误的情况;例如,它的源代码抛出异常。在这种情况下,上述评估时的类似步骤仍然会发生,包括对A的第二次await,通过
最后,考虑一个所有模块都异步完成的循环模块图:
加载和链接按前述方式进行,所有模块的[[Status]]都设置为
调用A.Evaluate()会调用
| 模块 | [[DFSIndex]] | [[DFSAncestorIndex]] | [[Status]] | [[AsyncEvaluation]] | [[AsyncParentModules]] | [[PendingAsyncDependencies]] |
|---|---|---|---|---|---|---|
| A | 0 | 0 | « » | 2 (B和C) | ||
| B | 1 | 0 | « A » | 1 (D) | ||
| C | 2 | 0 | « A » | 2 (D和E) | ||
| D | 3 | 0 | « B,C » | 0 | ||
| E | 4 | 4 | « C » | 0 |
我们假设E首先完成执行。当这种情况发生时,调用
| 模块 | [[DFSIndex]] | [[DFSAncestorIndex]] | [[Status]] | [[AsyncEvaluation]] | [[AsyncParentModules]] | [[PendingAsyncDependencies]] |
|---|---|---|---|---|---|---|
| C | 2 | 0 | < emu-val>true | « A » | 1 (D) | |
| E | 4 | 4 | « C » | 0 |
D是下一个完成的模块(因为它是唯一仍在执行的模块)。当这种情况发生时,再次调用await,则可能与B并行执行)。更新后的模块字段如下表
| 模块 | [[DFSIndex]] | [[DFSAncestorIndex]] | [[Status]] | [[AsyncEvaluation]] | [[AsyncParentModules]] | [[PendingAsyncDependencies]] |
|---|---|---|---|---|---|---|
| B | 1 | 0 | « A » | 0 | ||
| C | 2 | 0 | « A » | 0 | ||
| D | 3 | 0 | « B,C » | 0 |
我们假设C接下来完成执行。当这种情况发生时,再次调用
| 模块 | [[DFSIndex]] | [[DFSAncestorIndex]] | [[Status]] | [[AsyncEvaluation]] | [[AsyncParentModules]] | [[PendingAsyncDependencies]] |
|---|---|---|---|---|---|---|
| A | 0 | 0 | « » | 1 (B) | ||
| C | 2 | 0 | « A » | 0 |
然后,B完成执行。当这种情况发生时,再次调用
| 模块 | [[DFSIndex]] | [[DFSAncestorIndex]] | [[Status]] | [[AsyncEvaluation]] | [[AsyncParentModules]] | [[PendingAsyncDependencies]] |
|---|---|---|---|---|---|---|
| A | 0 | 0 | « » | 0 | ||
| B | 1 | 0 | « A » | 0 |
最后,A完成执行。当这种情况发生时,再次调用
| 模块 | [[DFSIndex]] | [[DFSAncestorIndex]] | [[Status]] | [[AsyncEvaluation]] | [[AsyncParentModules]] | [[PendingAsyncDependencies]] |
|---|---|---|---|---|---|---|
| A | 0 | 0 | « » | 0 |
或者,考虑一种失败情况,其中C在B完成执行之前返回错误。当这种情况发生时,调用
| 模块 | [[DFSIndex]] | [[DFSAncestorIndex]] | [[Status]] | [[AsyncEvaluation]] | [[AsyncParentModules]] | [[PendingAsyncDependencies]] | [[EvaluationError]] |
|---|---|---|---|---|---|---|---|
| A | 0 | 0 | « » | 1 (B) | |||
| C | 2 | 1 | « A » | 0 | C的评估错误 |
A将因与C相同的错误被拒绝,因为C将使用C的错误对A调用
| 模块 | [[DFSIndex]] | [[DFSAncestorIndex]] | [[Status]] | [[AsyncEvaluation]] | [[AsyncParentModules]] | [[PendingAsyncDependencies]] | [[EvaluationError]] |
|---|---|---|---|---|---|---|---|
| A | 0 | 0 | « » | 0 | C的 |
然后,B在没有错误的情况下完成执行。当这种情况发生时,再次调用
| 模块 | [[DFSIndex]] | [[DFSAncestorIndex]] | [[Status]] | [[AsyncEvaluation]] | [[AsyncParentModules]] | [[PendingAsyncDependencies]] | [[EvaluationError]] |
|---|---|---|---|---|---|---|---|
| A | 0 | 0 | « » | 0 | C的 |
||
| B | 1 | 0 | « A » | 0 |
源文本模块记录用于表示从
源文本模块记录可以与
除了在
| 字段名称 | 值类型 | 含义 |
|---|---|---|
| [[ECMAScriptCode]] | 解析节点 | 使用 |
| [[Context]] | ECMAScript 代码执行上下文 或
|
与此模块相关的 执行上下文。在模块的环境初始化之前,它为
|
| [[ImportMeta]] | 一个对象或 |
通过 import.meta 元属性公开的对象。在 ECMAScript 代码访问之前,它为 |
| [[ImportEntries]] | 记录列表 或 导入条目记录 | 从此模块代码派生的导入条目记录的列表。 |
| [[LocalExportEntries]] | 记录列表 或 导出条目记录 | 从此模块代码派生的导出条目记录的列表,这些条目记录对应于模块内的声明。 |
| [[IndirectExportEntries]] | 记录列表 或 导出条目记录 | 从此模块代码派生的导出条目记录的列表,这些条目记录对应于模块内的重新导出或 export * as namespace 声明中的导出。 |
| [[StarExportEntries]] | 记录列表 或 导出条目记录 | 从此模块代码派生的导出条目记录的列表,这些条目记录对应于模块内的 export * 声明,但不包括
export * as namespace 声明。
|
导入条目记录 是一种
| 字段名称 | 值类型 | 含义 |
|---|---|---|
| [[ModuleRequest]] | 字符串 | |
| [[ImportName]] | 字符串或 |
所需绑定由 [[ModuleRequest]] 标识的模块导出的名称。值
|
| [[LocalName]] | 字符串 | 用于在导入模块中本地访问导入值的名称。 |
| 导入语句形式 | [[ModuleRequest]] | [[ImportName]] | [[LocalName]] |
|---|---|---|---|
import v from "mod"; |
|||
import * as ns from "mod"; |
|||
import {x} from "mod"; |
|||
import {x as v} from "mod"; |
|||
import "mod"; |
不创建导入条目记录。 | ||
导出条目记录 是一种
| 字段名称 | 值类型 | 含义 |
|---|---|---|
| [[ExportName]] | 字符串或 |
用于模块导出此绑定的名称。 |
| [[ModuleRequest]] | 字符串或 |
|
| [[ImportName]] | 字符串、 |
所需绑定由 [[ModuleRequest]] 标识的模块导出的名称。如果 export * as ns from "mod"
声明。export * from "mod" 声明。
|
| [[LocalName]] | 字符串或 |
用于在导入模块中本地访问导出值的名称。如果导出值无法在模块中本地访问,则为 |
| 导出语句形式 | [[ExportName]] | [[ModuleRequest]] | [[ImportName]] | [[LocalName]] |
|---|---|---|---|---|
export var v; |
||||
export default function f() {} |
||||
export default function () {} |
||||
export default 42; |
||||
export {x}; |
||||
export {v as x}; |
||||
export {x} from "mod"; |
||||
export {v as x} from "mod"; |
||||
export * from "mod"; |
||||
export * as ns from "mod"; |
以下定义指定了
抽象操作 ParseModule 接受参数 sourceText (
await。
实现可以在解析模块源文本并分析其早期错误条件之前执行 ParseModule 操作。然而,任何错误的报告必须推迟到规范实际执行 ParseModule 操作时。
GetExportedNames 不会过滤掉或抛出具有模糊星号导出绑定的名称的异常。
ResolveExport 尝试将导入的绑定解析为实际定义的模块和本地绑定名称。定义模块可以是此方法所调用的
如果找到定义模块,则返回一个
调用时执行以下步骤:
default 导出。
default 导出不能由 export * from "mod" 声明提供。*
导入。抽象操作 GetImportedModule 接受参数 referrer(一个
HostLoadImportedModule 的实现必须符合以下要求:
实际执行的过程是
抽象操作 FinishLoadingImportedModule 接受参数 referrer(一个
抽象操作 GetModuleNamespace 接受参数 module(
GetModuleNamespace 永远不会抛出错误。相反,此时未解析的名称仅会被排除在命名空间之外。除非它们全部是未明确请求的模糊星号导出,否则它们稍后将导致实际的链接错误。
以上规则意味着
语法指导操作
它分散定义在以下产生式中:
ExportedNames 是模块显式映射到其本地名称绑定的外部可见名称。
它分段定义如下:
实现必须在评估相关 ECMAScript 语言结构时报告大多数错误。提前错误
是在评估包含错误的 eval 时报告,并阻止 eval 代码的评估。所有不是
实现必须将规范中“静态语义:提前错误”子条款中列出的任何情况报告为
实现不得将其他类型的错误视为
实现必须按规定报告所有错误,但以下情况除外:
eval、使用正则表达式字面量或使用 Function 或 RegExp 实现不得以下列方式扩展此规范:
toLocaleString 的方法)的行为不得扩展,除非 ECMA-402 中另有规定。: 紧跟在由 在 ECMAScript
除非另有说明,否则可作为函数调用的内置对象是具有
许多内置对象是函数:它们可以用参数调用。其中一些还是 new
运算符一起使用的函数。对于每个内置函数,本规范描述了该函数所需的参数以及该 new 表达式返回的特定对象实例的属性。
除非在特定函数的描述中另有说明,否则如果内置函数或
除非在特定函数的描述中另有说明,否则如果内置函数或
添加额外功能到内置函数集合的实现建议通过添加新函数而不是向现有函数添加新参数来实现。
除非另有说明,每个内置函数和每个内置 Function.prototype(
除非另有说明,每个内置原型对象的 [[Prototype]] 内部槽的值都是 Object.prototype(
如果本规范通过算法步骤定义了内置
未标识为
未标识为
本规范中定义的每个内置函数都是通过调用
每个内置
例如,
除非另有说明,内置
每个内置
为每个内置函数明确指定的
除非另有说明,内置
每个在
每个在
全局对象:
new操作符将其用作此属性的特性为 { [[Writable]]:
Infinity的值为
NaN的值为
undefined的值为
此函数是 %eval% 内置对象。
调用时执行以下步骤:
抽象操作 PerformEval 接受参数 x(一个
eval 和 eval 函数本身的
eval 函数的 如果调用上下文的代码或 eval 代码是 let、const 或
class 声明引入的绑定始终在新的词法环境中实例化。
parameterStrings 表示在使用某个函数 eval 调用的字符串。direct 表示评估是否为
HostEnsureCanCompileStrings 的默认实现是返回
抽象操作 EvalDeclarationInstantiation 接收参数 body(一个
该算法的替代版本在
该函数是内置对象%isFinite%。
它在调用时执行以下步骤:
该函数是内置对象%isNaN%。
它在调用时执行以下步骤:
ECMAScript 代码测试值 X 是否为 X !== X 的表达式。仅当
X 为
此函数通过将string参数的内容解释为十进制文字来生成一个数字值。
它是内置对象%parseFloat%。
它在调用时执行以下步骤:
此函数可能仅将string的前导部分解释为数字值;它会忽略任何不能解释为十进制文字符号的代码单元,并且不会提供任何指示被忽略的代码单元。
该函数根据指定的radix解释string的内容来生成一个整数
它是内置对象%parseInt%。
它在调用时执行以下步骤:
此函数可能仅将string的前导部分解释为整数值;它会忽略任何不能解释为整数符号的代码单元,并且不会提供任何指示被忽略的代码单元。
统一资源标识符(URI)是用于标识资源(例如网页或文件)和访问它们的传输协议(例如 HTTP 或 FTP)在互联网上的字符串。ECMAScript 语言本身不提供任何使用 URI 的支持,除了如本节所述的编码和解码
URI 的函数。encodeURI 和 decodeURI 旨在处理完整的
URI;它们假定任何保留字符都意在具有特殊意义(例如,作为分隔符),因此不进行编码。encodeURIComponent 和 decodeURIComponent
旨在处理 URI 的各个组件;它们假定任何保留字符代表文本,并且必须编码以避免在组件作为完整 URI 的一部分时具有特殊意义。
保留字符集基于 RFC 2396,并不反映最新的 RFC 3986 引入的更改。
许多 ECMAScript 实现提供了其他操作网页的函数和方法;这些函数超出了本标准的范围。
此函数计算 URI 的新版本,其中每个转义序列和 UTF-8 编码将被 encodeURI 函数引入的排序替换为它所表示的代码点的 UTF-16 编码。无法通过
encodeURI 引入的转义序列不会被替换。
这是 %decodeURI% 内置对象。
调用时执行以下步骤:
此函数计算 URI 的新版本,其中每个转义序列和 UTF-8 编码将被 encodeURIComponent 函数引入的排序替换为它所表示的代码点的 UTF-16 编码。
这是 %decodeURIComponent% 内置对象。
调用时执行以下步骤:
此函数计算 UTF-16 编码 (
这是 %encodeURI% 内置对象。
调用时执行以下步骤:
此函数计算 UTF-16 编码 (
这是 %encodeURIComponent% 内置对象。
调用时执行以下步骤:
抽象操作 Encode 接受参数 string(字符串)和 extraUnescaped(字符串),并返回一个
由于百分比编码用于表示单个字节,因此单个代码点可能表示为多个连续的转义序列(每个转义序列对应其 8 位 UTF-8 代码单元)。
抽象操作 Decode 接受参数 string(字符串)和 preserveEscapeSet(字符串),并返回一个
RFC 3629 禁止解码无效的 UTF-8 字节序列。例如,无效序列 0xC0 0x80 不得解码为代码单元 0x0000。Decode 算法的实现需要在遇到此类无效序列时抛出
抽象操作 ParseHexOctet 接受参数 string(字符串)和 position(非负整数),并返回一个非负整数或包含
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
见
Object
extends 子句的值。此函数调用时执行以下步骤:
Object
此函数将一个或多个源对象的所有可枚举自身属性的值复制到一个 target 对象。
调用时执行以下步骤:
此函数的
此函数创建一个具有指定原型的新对象。
调用时执行以下步骤:
此函数添加自身属性和/或更新对象现有自身属性的属性。
调用时执行以下步骤:
抽象操作 ObjectDefineProperties 接受参数 O(对象)和 Properties(
此函数添加自身属性和/或更新对象现有自身属性的属性。
调用时执行以下步骤:
此函数调用时执行以下步骤:
此函数调用时执行以下步骤:
此函数调用时执行以下步骤:
此函数调用时执行以下步骤:
此函数调用时执行以下步骤:
此函数调用时执行以下步骤:
此函数调用时执行以下步骤:
抽象操作 GetOwnPropertyKeys 接受参数 O(
此函数调用时执行以下步骤:
callbackfn 应该是一个接受两个参数的函数。groupBy 按升序调用 callbackfn 一次,每次调用
items 中的一个元素,并构建一个新对象。callbackfn 返回的每个值都被强制转换为
callbackfn 以两个参数调用:元素的值和元素的索引。
groupBy 的返回值是一个对象,不从
此函数调用时执行以下步骤:
此函数调用时执行以下步骤:
此函数调用时执行以下步骤:
此函数调用时执行以下步骤:
此函数调用时执行以下步骤:
此函数调用时执行以下步骤:
此函数调用时执行以下步骤:
此函数调用时执行以下步骤:
Object.prototype 的初始值为
此属性具有 { [[Writable]]:
此函数调用时执行以下步骤:
此函数调用时执行以下步骤:
此函数调用时执行以下步骤:
Object 原型对象:
Object.prototype.constructor 的初始值是
调用此方法时,执行以下步骤:
调用此方法时,执行以下步骤:
调用此方法时,执行以下步骤:
此方法不考虑原型链中的对象。
调用此方法时,执行以下步骤:
此方法的可选参数未使用,但旨在与 ECMA-402 toLocaleString 方法使用的参数模式对应。不包括 ECMA-402 支持的实现不得将这些参数位置用于其他目的。
此方法为没有区域敏感 toString 行为的对象提供了通用的 toLocaleString
实现。Array、Number、Date 和 toLocaleString 方法。
ECMA-402 故意不提供此默认实现的替代方案。
调用此方法时,执行以下步骤:
历史上,此方法偶尔被用来访问 [[Class]] 内部插槽的字符串值,该插槽在之前的版本规范中用作各种内置对象的名义类型标签。上面的
toString 定义保留了兼容性,以供使用 toString
作为这些特定内置对象的测试的遗留代码使用。它不提供其他种类的内置或程序定义对象的可靠类型测试机制。此外,程序可以使用
调用此方法时,执行以下步骤:
Object.prototype.__proto__ 是一个
[[Get]] 属性的值是一个内置函数,不需要参数。调用时执行以下步骤:
[[Set]] 属性的值是一个内置函数,接受一个参数 proto。调用时执行以下步骤:
调用此方法时,执行以下步骤:
调用此方法时,执行以下步骤:
调用此方法时,执行以下步骤:
调用此方法时,执行以下步骤:
Object 实例没有超出从
Function
Function(…)
等价于对象创建表达式 new Function(…),并使用相同的参数。extends子句的值。意图继承指定 Function 行为的子类super调用,以创建并初始化具有内置函数行为所需内部槽的子类实例。所有
ECMAScript 定义最后一个参数(如果有)指定函数的主体(可执行代码);任何前面的参数指定形式参数。
当调用此函数时,执行以下步骤:
可以有一个参数用于指定每个形式参数,但这不是必要的。例如,以下三个表达式生成相同的结果:
new Function("a", "b", "c", "return a+b+c")
new Function("a, b, c", "return a+b+c")
new Function("a,b", "c", "return a+b+c")
抽象操作 CreateDynamicFunction 接受参数 constructor(一个 new的
new Function("/*", "*/ ) {") 不会解析为一个函数。CreateDynamicFunction 在它创建的任何 kind 不为
Function
Function.prototype 的值是
该属性具有 { [[Writable]]:
Function 原型对象:
new 运算符一起用作 Function 原型对象被指定为一个
当调用此方法时,执行以下步骤:
当调用此方法时,执行以下步骤:
如果 Target 是一个箭头函数或一个
当调用此方法时,执行以下步骤:
Function.prototype.constructor 的初始值是
当调用此方法时,执行以下步骤:
当调用此方法时,执行以下步骤:
此属性具有 { [[Writable]]:
此属性是不可写且不可配置的,以防止可能用于全局暴露绑定函数的目标函数的篡改。
此方法的
每个函数实例都是一个 ECMAScript Function.prototype.bind方法
函数实例具有以下属性:
不具有该规范关联的上下文名称的匿名函数对象使用空字符串作为
可以用作
此属性的特性为 { [[Writable]]:
HostHasSourceTextAvailable 的实现必须符合以下要求:
HostHasSourceTextAvailable 的默认实现是返回
Boolean
extends 子句的值使用。打算继承指定 Boolean 行为的子类 super 调用,以使用
[[BooleanData]] 内部插槽创建和初始化子类实例。
调用此函数时执行以下步骤:
Boolean
Boolean.prototype 的初始值是
此属性的特性为 { [[Writable]]:
Boolean 原型对象:
Boolean.prototype.constructor 的初始值是
调用此方法时,执行以下步骤:
调用此方法时,执行以下步骤:
抽象操作 ThisBooleanValue 接受参数 value(一个
Boolean 实例是从
Symbol
new 操作符一起使用。extends 子句的值,但对其进行 super 调用将引发异常。调用此函数时执行以下步骤:
Symbol
Symbol.asyncIterator 的初始值是知名符号
此属性具有 { [[Writable]]:
调用此函数时执行以下步骤:
GlobalSymbolRegistry 是一个全局可用的仅追加的
Symbol.hasInstance 的初始值是知名符号
此属性具有 { [[Writable]]:
Symbol.isConcatSpreadable 的初始值是知名符号
此属性具有 { [[Writable]]:
Symbol.iterator 的初始值是知名符号
此属性具有 { [[Writable]]:
调用此函数时执行以下步骤:
Symbol.match 的初始值是知名符号
此属性具有 { [[Writable]]:
Symbol.matchAll 的初始值是知名符号
此属性具有 { [[Writable]]:
Symbol.prototype 的初始值是
此属性具有 { [[Writable]]:
Symbol.replace 的初始值是知名符号
此属性具有 { [[Writable]]:
Symbol.search 的初始值是知名符号
此属性具有 { [[Writable]]:
Symbol.species 的初始值是知名符号
此属性具有 { [[Writable]]:
Symbol.split 的初始值是知名符号
此属性具有 { [[Writable]]:
Symbol.toPrimitive 的初始值是知名符号
此属性具有 { [[Writable]]:
Symbol.toStringTag 的初始值是知名符号
此属性具有 { [[Writable]]:
Symbol.unscopables 的初始值是知名符号
此属性具有 { [[Writable]]:
Symbol 原型对象:
Symbol.prototype.constructor 的初始值是
Symbol.prototype.description 是一个
调用此方法时执行以下步骤:
抽象操作 SymbolDescriptiveString 接受参数 sym(一个符号)并返回一个字符串。调用时执行以下步骤:
调用此方法时执行以下步骤:
抽象操作 ThisSymbolValue 接受参数 value(一个
此方法由 ECMAScript 语言操作符调用,以将 Symbol 对象转换为原始值。
调用时执行以下步骤:
忽略此参数。
此属性具有 { [[Writable]]:
此方法的
Symbol.toStringTag 的初始值是字符串
此属性具有 { [[Writable]]:
Symbol 实例是
抽象操作 KeyForSymbol 接受参数 sym(一个符号)并返回一个字符串或
Error 对象的实例在运行时错误发生时作为异常被抛出。Error 对象也可以作为用户定义异常类的基对象。
当 ECMAScript 实现检测到运行时错误时,它会抛出一个由
Error
Error(…) 等同于对象创建表达式 new Error(…),使用相同的参数。
extends 子句的值。打算继承指定 Error 行为的子类 super 调用,以使用 [[ErrorData]] 内部插槽创建并初始化子类实例。
调用此函数时执行以下步骤:
Error
Error.prototype 的初始值是
此属性具有 { [[Writable]]:
Error 原型对象:
Error.prototype.constructor 的初始值是
Error.prototype.message 的初始值是空字符串。
Error.prototype.name 的初始值是
调用此方法时执行以下步骤:
Error 实例是 Object.prototype.toString 中识别
Error、AggregateError 和 NativeError 实例。
当检测到运行时错误时,会抛出一个由以下 NativeError 对象之一或 AggregateError 对象的新实例。所有 NativeError
对象共享相同的结构,如
EvalError
此异常当前未在本规范中使用。为了与本规范的先前版本兼容,此对象仍然保留。
RangeError
表示不在允许值的集合或范围内的值。
ReferenceError
表示检测到无效引用。
SyntaxError
表示发生了解析错误。
TypeError
当没有其他 NativeError 对象适合表示失败原因时,TypeError 用于表示操作失败。
URIError
表示全局 URI 处理函数之一的使用方式与其定义不兼容。
当 ECMAScript 实现检测到运行时错误时,它会抛出一个由
对于每个错误对象,定义中的 NativeError 引用应替换为
每个 NativeError
NativeError(…) 等同于对象创建表达式
new NativeError(…) 具有相同的参数。
extends 子句的值。打算继承指定 NativeError 行为的子类 super 调用,以使用 [[ErrorData]] 内部插槽创建并初始化子类实例。
调用每个 NativeError 函数时执行以下步骤:
"%NativeError.prototype%", « [[ErrorData]] »)。
在步骤
每个 NativeError
NativeError.prototype 的初始值是一个 NativeError 原型对象(
此属性具有 { [[Writable]]:
每个 NativeError 原型对象:
给定 NativeError 的原型的
给定 NativeError 的原型的
给定 NativeError 的原型的
NativeError 实例是 Object.prototype.toString 中识别
Error、AggregateError 或 NativeError 实例。
AggregateError
AggregateError(…) 等同于对象创建表达式 new AggregateError(…),使用相同的参数。extends 子句的值。打算继承指定 AggregateError 行为的子类 super 调用,以使用 [[ErrorData]] 内部插槽创建并初始化子类实例。
调用此函数时执行以下步骤:
AggregateError
AggregateError.prototype 的初始值是
此属性具有 { [[Writable]]:
AggregateError 原型对象:
AggregateError.prototype.constructor 的初始值是
AggregateError.prototype.message 的初始值是空字符串。
AggregateError.prototype.name 的初始值是
AggregateError 实例是 Object.prototype.toString 中识别 Error、AggregateError 或 NativeError 实例。
抽象操作 InstallErrorCause 接受参数 O(一个对象)和 options(一个
Number
extends 子句的值。继承指定 Number 行为的子类 super 调用,以创建并初始化带有 [[NumberData]] 内部槽的子类实例。
当被调用时,此函数执行以下步骤:
Number
Number.EPSILON 的值是
此属性具有 { [[Writable]]:
当被调用时,此函数执行以下步骤:
当被调用时,此函数执行以下步骤:
当被调用时,此函数执行以下步骤:
此函数与全局 isNaN 函数 (
当被调用时,此函数执行以下步骤:
由于 Number.MAX_SAFE_INTEGER 的整数的 9007199254740992 和 9007199254740993 都评估为 Number 值
Number.MAX_SAFE_INTEGER 的值为
此属性具有 { [[Writable]]:
Number.MAX_VALUE 的值是
此属性具有 { [[Writable]]:
由于 Number.MIN_SAFE_INTEGER 的整数的 -9007199254740992 和 -9007199254740993 都评估为 Number 值
Number.MIN_SAFE_INTEGER 的值为
此属性具有 { [[Writable]]:
Number.MIN_VALUE 的值是
在 Number.MIN_VALUE 的值必须是实现实际上可以表示的最小非零正值。
此属性具有 { [[Writable]]:
Number.NaN 的值是
此属性具有 { [[Writable]]:
Number.NEGATIVE_INFINITY 的值是
此属性具有 { [[Writable]]:
Number.parseFloat 属性的初始值是
Number.parseInt 属性的初始值是
Number.POSITIVE_INFINITY 的值是
此属性具有 { [[Writable]]:
Number.prototype 的初始值是
此属性具有 { [[Writable]]:
Number 原型对象:
除非明确声明,否则以下定义的 Number 原型对象的方法不是通用的,传递给它们的
规范中方法中的 "this Number value" 术语是指调用抽象操作
Number.prototype.constructor 的初始值是
此方法返回一个字符串,其中包含此 Number 值,以十进制指数表示法表示,小数点前一位数字,小数点后 fractionDigits 位数字。如果
fractionDigits 为
当被调用时,它执行以下步骤:
此方法返回一个字符串,其中包含此 Number 值,以十进制定点表示法表示,小数点后 fractionDigits 位数字。如果 fractionDigits
为
当被调用时,它执行以下步骤:
toFixed 的输出对于某些值可能比 toString 更精确,因为 toString 只打印足够的有效数字以区分该数值与相邻的 Number
值。例如,
(1000000000000000128).toString() 返回
(1000000000000000128).toFixed(0) 返回
包括 ECMA-402 国际化 API 的 ECMAScript 实现必须按 ECMA-402 规范指定实现此方法。如果 ECMAScript 实现不包括 ECMA-402 API,则使用此方法的以下规范:
此方法生成一个字符串值,该字符串值根据 toString 相同的值,但不鼓励这样做。
此方法的可选参数含义在 ECMA-402 规范中定义;不包括 ECMA-402 支持的实现不得使用这些参数位置做其他用途。
此方法返回一个字符串,其中包含此 Number 值,以十进制指数表示法表示,小数点前一位数字,小数点后 precision - 1 位有效数字,或以十进制定点表示法表示,具有
precision 个有效数字。如果 precision 为
当被调用时,它执行以下步骤:
当被调用时,此方法执行以下步骤:
此方法不是通用的;如果其
此方法的
抽象操作 ThisNumberValue 接受参数 value(一个
Number 实例是
BigInt
new 操作符一起使用或进行子类化。它可以用作类定义的 extends 子句的值,但对 BigInt
super 调用将导致异常。
当调用时,此函数执行以下步骤:
抽象操作 NumberToBigInt 接受参数 number(一个 Number),并返回
BigInt
此函数在调用时执行以下步骤:
此函数在调用时执行以下步骤:
BigInt.prototype 的初始值为
此属性具有 { [[Writable]]:
BigInt 原型对象:
方法规范中的短语“这个 BigInt 值”指的是通过调用抽象操作
BigInt.prototype.constructor 的初始值为
包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 规范实现此方法。如果 ECMAScript 实现不包含 ECMA-402 API,则使用以下方法规范:
此方法生成一个字符串值,该值根据 toString 相同的内容。
此方法的可选参数的含义在 ECMA-402 规范中定义;不包含 ECMA-402 支持的实现不得将这些参数位置用于其他任何用途。
此方法在调用时执行以下步骤:
此方法不是通用的;如果其
抽象操作 ThisBigIntValue 接受参数 value(一个
此属性具有 { [[Writable]]:
BigInt 实例是
数学对象:
new 操作符使用.自然对数的底数
此属性具有 { [[Writable]]:
10 的自然对数的
此属性具有 { [[Writable]]:
2 的自然对数的
此属性具有 { [[Writable]]:
自然对数的底数 e 的以 10 为底的对数的
此属性具有 { [[Writable]]:
Math.LOG10E 的值大约是 Math.LN10 的倒数。
自然对数的底数 e 的以 2 为底的对数的
此属性具有 { [[Writable]]:
Math.LOG2E 的值大约是 Math.LN2 的倒数。
圆的周长与直径的比值 π 的
此属性具有 { [[Writable]]:
1/2 的平方根的
此属性具有 { [[Writable]]:
Math.SQRT1_2 的值大约是 Math.SQRT2 的倒数。
2 的平方根的
此属性具有 { [[Writable]]:
此属性具有 { [[Writable]]:
函数
acos、acosh、asin、asinh、atan、atanh、atan2、cbrt、cos、cosh、exp、expm1、hypot、log、log1p、log2、log10、pow、random、sin、sinh、sqrt、tan
和 tanh
的行为在此并未精确指定,只是要求对于某些有意义的边界值给出特定结果。对于其他参数值,这些函数旨在计算熟悉的数学函数的近似值,但在选择近似算法时允许有一定的自由度。总体意图是实现者应该能够在给定硬件平台上的
ECMAScript 中使用同样适用于该平台上的 C 程序员的数学库。
虽然算法的选择留给实现决定,但建议(但本标准未规定)实现使用 fdlibm,这是 Sun Microsystems 提供的自由分发的数学库(http://www.netlib.org/fdlibm)。
该函数返回 x 的绝对值;结果与 x 具有相同的幅度,但符号为正。
调用时执行以下步骤:
该函数返回 x 的反余弦值。结果以弧度表示,位于从
调用时执行以下步骤:
该函数返回 x 的反双曲余弦值。
调用时执行以下步骤:
该函数返回 x 的反正弦值。结果以弧度表示,位于从
调用时执行以下步骤:
该函数返回 x 的反双曲正弦值。
调用时执行以下步骤:
该函数返回 x 的反正切值。结果以弧度表示,位于从
调用时执行以下步骤:
该函数返回 x 的反双曲正切值。
调用时执行以下步骤:
该函数返回参数 y 和 x 的商
调用时执行以下步骤:
此函数返回 x 的立方根。
调用时执行以下步骤:
此函数返回不小于 x 的最小(最接近 -∞)
调用时执行以下步骤:
Math.ceil(x) 的值与 -Math.floor(-x) 的值相同。
此函数在调用时执行以下步骤:
如果 n 是
此函数返回 x 的余弦值。参数以弧度表示。
调用时执行以下步骤:
此函数返回 x 的双曲余弦值。
调用时执行以下步骤:
Math.cosh(x) 的值与 (Math.exp(x) + Math.exp(-x)) / 2 的值相同。
此函数返回 x 的指数函数值(e 的 x 次幂,其中 e 是自然对数的底)。
调用时执行以下步骤:
此函数返回从 x 的指数函数值中减去 1 的结果(e 的 x 次幂,其中 e 是自然对数的底)。该结果的计算方式即使在 x 值接近 0 时也能保证准确。
调用时执行以下步骤:
此函数返回不大于 x 的最大(最接近 +∞)
调用时执行以下步骤:
Math.floor(x) 的值与 -Math.ceil(-x) 的值相同。
此函数在调用时执行以下步骤:
给定零个或多个参数,此函数返回其参数的平方和的平方根。
调用时执行以下步骤:
此函数的
实现应注意避免在此函数以两个或更多参数调用时由于溢出和下溢导致的精度损失,这在天真的实现中容易发生。
此函数在调用时执行以下步骤:
此函数返回 x 的自然对数。
调用时执行以下步骤:
此函数返回 1 + x 的自然对数。即使当 x 的值接近于零时,该结果的计算也很准确。
调用时执行以下步骤:
此函数返回 x 的以 10 为底的对数。
调用时执行以下步骤:
此函数返回 x 的以 2 为底的对数。
调用时执行以下步骤:
给定零个或多个参数,此函数调用
调用时执行以下步骤:
用于确定最大值的值比较是使用
此函数的
给定零个或多个参数,此函数调用
调用时执行以下步骤:
用于确定最小值的值比较是使用
此函数的
此函数在调用时执行以下步骤:
此函数返回一个带正号的 Number 值,大于或等于
为不同 Math.random 函数必须从连续调用中产生不同的值序列。
此函数返回最接近 x 并且是整数的 Number 值。如果两个
调用时执行以下步骤:
Math.round(3.5) 返回 4,但 Math.round(-3.5) 返回 -3。
Math.round(x) 的值不总是与 Math.floor(x + 0.5) 的值相同。当 x 为
x 小于 Math.round(x) 返回
Math.floor(x + 0.5) 返回
x + 0.5 时的内部舍入,Math.round(x) 可能与
Math.floor(x + 0.5) 的值不同。
此函数返回 x 的符号,指示 x 是正数、负数还是零。
调用时执行以下步骤:
此函数返回 x 的正弦值。参数以弧度表示。
调用时执行以下步骤:
此函数返回 x 的双曲正弦值。
调用时执行以下步骤:
Math.sinh(x) 的值与 (Math.exp(x) - Math.exp(-x)) / 2 的值相同。
此函数返回 x 的平方根。
调用时执行以下步骤:
此函数返回 x 的正切值。参数以弧度表示。
调用时执行以下步骤:
此函数返回 x 的双曲正切值。
调用时执行以下步骤:
Math.tanh(x) 的值与
(Math.exp(x) - Math.exp(-x)) / (Math.exp(x) + Math.exp(-x)) 的值相同。
此函数返回数值 x 的整数部分,去除任何小数位。如果 x 已经是整数,结果是 x。
调用时执行以下步骤:
以下
ECMAScript 中的时间测量类似于 POSIX 中的时间测量,特别是在定义上共享了如下内容:采用公历日期,纪元时间为 1970 年 1 月 1 日凌晨 0 时 0 分 0 秒(UTC),并将每一天精确计为 86,400 秒(每秒包含 1000 毫秒)。
ECMAScript 的 时间值
时间值不考虑 UTC 闰秒——不存在表示正闰秒内瞬间的时间值,并且存在表示由负闰秒从 UTC 时间线中移除的瞬间的时间值。然而,时间值的定义仍然能与 UTC 分段对齐,仅在闰秒边界处存在不连续性,且在非闰秒时段内零差异。
一个数字可以精确表示从 -9,007,199,254,740,992 到 9,007,199,254,740,992 的所有
1970 年 1 月 1 日凌晨 0 时 0 分 0 秒(UTC)这一确切时刻用时间值
在公历日期中,闰年是精确地指能被 4 整除且要么能被 400 整除,要么不能被 100 整除的年份。
公历日期的 400 年周期包含 97 个闰年。这产生了平均每年 365.2425 天,相当于 31,556,952,000 毫秒。因此,数字可以用毫秒精度精确表示的最大范围约为相对于 1970 年的 -285,426 到 285,426 年。本文指定的时间值支持的较小范围约为相对于 1970 年的 -273,790 到 273,790 年。
以下章节中的算法引用了这些常量。
抽象操作 Day 接受参数 t(一个
抽象操作 TimeWithinDay 接受参数 t(一个
抽象操作 DaysInYear 接受参数 y(一个
抽象操作 DayFromYear 接受参数 y(一个
抽象操作 TimeFromYear 接受参数 y(一个
抽象操作 YearFromTime 接受参数 t(一个
抽象操作 DayWithinYear 接受参数 t(一个
抽象操作 InLeapYear 接受参数 t(一个
抽象操作 MonthFromTime 接受参数 t(一个
抽象操作 DateFromTime 接受参数 t(一个
抽象操作 WeekDay 接受参数 t(一个
抽象操作 HourFromTime 接受参数 t(一个
抽象操作 MinFromTime 接受参数 t(一个
抽象操作 SecFromTime 接受参数 t(一个
抽象操作 msFromTime 接受参数 t(一个
抽象操作 GetUTCEpochNanoseconds 接受参数 year(一个
ECMAScript 中的时区由时区标识符表示,这些标识符是完全由
一个主要时区标识符是某个可用命名时区的首选标识符。 一个非主要时区标识符是某个可用命名时区的非主要标识符。 一个可用命名时区标识符可以是主要时区标识符或非主要时区标识符。 每个可用命名时区标识符与一个可用命名时区完全对应。 每个可用命名时区完全对应一个主要时区标识符和零个或多个非主要时区标识符。
ECMAScript 实现必须支持标识符为
遵循 ECMA-402 国际化 API 规范中描述的时区要求的实现称为时区感知。
时区感知的实现必须支持与 IANA 时区数据库的区域和链接名称对应的可用命名时区,并且仅支持这些名称。
在时区感知的实现中,主要时区标识符是 IANA 时区数据库中的区域名称,非主要时区标识符是链接名称,除非被
抽象操作 GetNamedTimeZoneEpochNanoseconds 接受参数 timeZoneIdentifier(一个字符串),year(一个
当输入表示由于负时区转换(例如,当夏令时结束或时区规则更改导致时区偏移减少)而发生多次的本地时间时,返回的列表将有多个元素,并按数值升序排序。 当输入表示由于正时区转换(例如,当夏令时开始或时区规则更改导致时区偏移增加)而跳过的本地时间时,返回的列表将为空。 否则,返回的列表将只有一个元素。
在不包含任何时区本地政治规则的 ECMAScript 实现中,GetNamedTimeZoneEpochNanoseconds 的默认实现在调用时执行以下步骤:
对于
2017年11月5日凌晨1:30在 America/New_York 被重复两次,因此
GetNamedTimeZoneEpochNanoseconds(
2017年3月12日凌晨2:30在 America/New_York 不存在,因此
GetNamedTimeZoneEpochNanoseconds(
抽象操作 GetNamedTimeZoneOffsetNanoseconds 接受参数
timeZoneIdentifier(一个字符串)和epochNanoseconds(一个 BigInt)并返回一个
返回的
在不包含任何时区本地政治规则的 ECMAScript 实现中,GetNamedTimeZoneOffsetNanoseconds 的默认实现在调用时执行以下步骤:
时区偏移值可以是正值或负值。
一个时区标识符记录是一个
时区标识符记录有
如果[[Identifier]]是一个
抽象操作 AvailableNamedTimeZoneIdentifiers 不接受任何参数,返回一个
为了确保实现通常在Date对象的方法中提供的功能级别,建议SystemTimeZoneIdentifier返回一个对应于
例如,如果
抽象操作LocalTime接受参数t(一个
如果实现中没有本地时间t的政治规则,结果是t,因为
对于
抽象操作UTC接受参数t(一个数字)并返回一个
输入t名义上是一个
如果实现中没有本地时间t的政治规则,结果是t,因为
对于
2017年11月5日凌晨1:30在America/New_York被重复两次(倒退),但它必须被解释为1:30 AM UTC-04而不是1:30 AM UTC-05。在UTC(
2017年3月12日凌晨2:30在America/New_York不存在,但它必须被解释为2:30 AM UTC-05(相当于3:30 AM UTC-04)。在UTC(
抽象操作 MakeTime 接受参数 hour(一个数字)、min(一个数字)、sec(一个数字)和 ms(一个数字),并返回一个数字。它计算毫秒数。当被调用时执行以下步骤:
MakeTime 中的算术运算是浮点运算,它不是结合律的,因此必须按正确的顺序执行操作。
抽象操作 MakeDay 接受参数 year(一个数字)、month(一个数字)和 date(一个数字),并返回一个数字。它计算天数。当被调用时执行以下步骤:
抽象操作 MakeDate 接受参数 day(一个数字)和 time(一个数字),并返回一个数字。它计算毫秒数。当被调用时执行以下步骤:
抽象操作 MakeFullYear 接受参数 year(一个数字)并返回一个
抽象操作 TimeClip 接受参数 time(一个数字)并返回一个数字。它计算毫秒数。当被调用时执行以下步骤:
ECMAScript 定义了一种基于 ISO 8601 日历日期扩展格式的日期时间字符串交换格式。格式如下:YYYY-MM-DDTHH:mm:ss.sssZ
其中各元素如下:
YYYY
|
是公历纪年的年份,以四位十进制数字表示,范围从 0000 到 9999,或者是以 |
-
|
|
MM
|
是年份中的月份,以两位十进制数字表示,从 01(1月)到 12(12月)。 |
DD
|
是月份中的日期,以两位十进制数字表示,从 01 到 31。 |
T
|
|
HH
|
是从午夜开始经过的完整小时数,以两位十进制数字表示,从 00 到 24。 |
:
|
|
mm
|
是从小时开始经过的完整分钟数,以两位十进制数字表示,从 00 到 59。 |
ss
|
是从分钟开始经过的完整秒数,以两位十进制数字表示,从 00 到 59。 |
.
|
|
sss
|
是从秒开始经过的完整毫秒数,以三位十进制数字表示。 |
Z
|
是 UTC 偏移的表示形式,指定为 HH:mm 表示( |
这种格式包括仅日期形式:
YYYY YYYY-MM YYYY-MM-DD
它还包括“日期时间”形式,这些形式由上述某种仅日期形式后紧接以下某种时间形式,并可附加一个可选的 UTC 偏移表示:
THH:mm THH:mm:ss THH:mm:ss.sss
包含超出范围或不符合规范的元素的字符串不是此格式的有效实例。
由于每一天都是从午夜开始和结束的,因此有两种表示法 00:00 和 24:00
可以区分与同一日期相关的两个午夜。这意味着以下两种表示法指的是完全相同的时间点:1995-02-04T24:00 和
1995-02-05T00:00。这种将后一种形式解释为“日历日的结束”的方式与 ISO 8601
保持一致,尽管该规范将其保留用于描述时间间隔,并且不允许在表示单个时间点时使用它。
目前没有国际标准规定民用时区的缩写,如 CET、EST 等,有时甚至同一个缩写被用于两个完全不同的时区。出于这个原因,ISO 8601 和此格式都规定了时区偏移的数字表示法。
覆盖从1970年1月1日向前或向后约273,790年的完整Date.parse
带有扩展年份的日期时间值示例:
| -271821-04-20T00:00:00Z | 公元前271822年 |
| -000001-01-01T00:00:00Z | 公元前2年 |
| +000000-01-01T00:00:00Z | 公元前1年 |
| +000001-01-01T00:00:00Z | 公元1年 |
| +001970-01-01T00:00:00Z | 公元1970年 |
| +002009-12-15T00:00:00Z | 公元2009年 |
| +275760-09-13T00:00:00Z | 公元275760年 |
ECMAScript定义了一个基于ISO 8601的UTC偏移字符串交换格式。
该格式由以下语法描述。
该语法中使用的Unicode代码点列在
| 代码点 | Unicode名称 | 缩写 |
|---|---|---|
U+2212
|
负号 | <MINUS> |
抽象操作 IsTimeZoneOffsetString 接受参数 offsetString(一个字符串),并返回一个布尔值。返回值指示 offsetString
是否符合
抽象操作 ParseTimeZoneOffsetString 接受参数 offsetString(一个字符串),并返回一个
Date 构造函数
extends 子句的值。继承 Date 指定行为的子类 super 调用,以创建并初始化带有 [[DateValue]] 内部槽的子类实例。调用此函数时执行以下步骤:
Date
此函数返回标识调用发生时 UTC 日期和时间的
该函数对其参数应用
如果字符串符合 MM 或 DD 元素缺失时,使用 HH、mm 或
ss 元素缺失时,使用 sss 元素缺失时,使用
如果 x 是任何在特定 ECMAScript 实现中毫秒数为零的 Date,则在该实现中,以下所有表达式应产生相同的数值,如果所有引用的属性具有其初始值:
x.valueOf()
Date.parse(x.toString())
Date.parse(x.toUTCString())
Date.parse(x.toISOString())
然而,表达式
Date.parse(x.toLocaleString())
不要求产生与前面三个表达式相同的数值,并且通常,当给定任何不符合日期时间字符串格式(toString 或 toUTCString 方法生成的字符串值时,该函数产生的值是
Date.prototype 的初始值是
此属性具有以下属性:{ [[Writable]]:
调用此函数时执行以下步骤:
此函数的
此函数与 Date
Date 原型对象:
除非明确定义为其他情况,下面定义的 Date 原型对象的方法不是泛型方法,传递给它们的
初始值 Date.prototype.constructor 是
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
This method 的
如果 month 未传入,则此方法表现得如同 month 传入了 getMonth() 的返回值一样。如果
date 未传入,则表现得如同 date 传入了 getDate() 的返回值一样。
调用此方法时执行以下步骤:
This method 的
如果 min 未被传入,此方法表现得如同 min 被传入了 getMinutes() 的返回值一样。如果
sec 未被传入,此方法表现得如同 sec 被传入了 getSeconds() 的返回值一样。如果 ms
未被传入,此方法表现得如同 ms 被传入了 getMilliseconds() 的返回值一样。
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
This method 的
如果 sec 未被传入,此方法表现得如同 sec 被传入了 getSeconds() 的返回值一样。如果 ms
未被传入,此方法表现得如同 ms 被传入了 getMilliseconds() 的返回值一样。
调用此方法时执行以下步骤:
此方法的
如果 date 不存在,此方法的行为就像 date 存在且其值为 getDate()。
调用此方法时执行以下步骤:
此方法的
如果 ms 不存在,此方法的行为就像 ms 存在且其值为 getMilliseconds()。
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
This method's
如果没有提供 month,此方法的行为如同提供了值 getUTCMonth()。如果没有提供 date,其行为如同提供了值
getUTCDate()。
调用此方法时执行以下步骤:
This method's
如果没有提供 min,此方法的行为如同提供了值 getUTCMinutes()。如果没有提供 sec,其行为如同提供了值
getUTCSeconds()。如果没有提供 ms,其行为如同提供了值 getUTCMilliseconds()。
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
此方法的
如果没有提供 sec,此方法的行为如同提供了值 getUTCSeconds()。如果没有提供 ms,其行为如同提供了值
getUTCMilliseconds()。
调用此方法时执行以下步骤:
此方法的
如果没有提供 date,此方法的行为如同提供了值 getUTCDate()。
调用此方法时执行以下步骤:
此方法的
如果没有提供 ms,此方法的行为如同提供了值 getUTCMilliseconds()。
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
此方法提供 Date 的字符串表示形式,以供 JSON.stringify (
调用此方法时执行以下步骤:
忽略参数。
此方法有意为通用方法;它不要求其 toISOString 方法。
包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 规范指定的方法实现此方法。如果 ECMAScript 实现不包含 ECMA-402 API,则使用以下此方法的规范:
此方法返回一个字符串值。字符串的内容是
此方法的可选参数的含义在 ECMA-402 规范中定义;不包含 ECMA-402 支持的实现不得将这些参数位置用于其他任何目的。
包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 规范指定的方法实现此方法。如果 ECMAScript 实现不包含 ECMA-402 API,则使用以下此方法的规范:
此方法返回一个字符串值。字符串的内容是
此方法的可选参数的含义在 ECMA-402 规范中定义;不包含 ECMA-402 支持的实现不得将这些参数位置用于其他任何目的。
包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 规范指定的方法实现此方法。如果 ECMAScript 实现不包含 ECMA-402 API,则使用以下此方法的规范:
此方法返回一个字符串值。字符串的内容是
此方法的可选参数的含义在 ECMA-402 规范中定义;不包含 ECMA-402 支持的实现不得将这些参数位置用于其他任何目的。
调用此方法时,它会执行以下步骤:
对于任何 Date 对象 d,如果 d.[[DateValue]] 能被 1000 整除,则
Date.parse(d.toString()) 的结果等于 d.valueOf()。参见
此方法不是通用的;如果其
抽象操作 TimeString 接受参数 tv(一个数字,但不能是
抽象操作 DateString 接受参数 tv(一个数字,但不能是
| 编号 | 名称 |
|---|---|
| 编号 | 名称 |
|---|---|
抽象操作 TimeZoneString 接受参数 tv(一个
抽象操作 ToDateString 接受参数 tv(一个
此方法调用时执行以下步骤:
此方法返回一个字符串,表示与
调用时执行以下步骤:
此方法调用时执行以下步骤:
此方法由 ECMAScript 语言操作符调用,用于将 Date 对象转换为原始值。hint 允许的值为
调用时执行以下步骤:
该属性的特性为 { [[Writable]]:
此方法的
Date 实例是
[[DateValue]] 内部槽位表示此 Date 对象所表示的
String
extends 子句的值。希望继承指定 String 行为的子类 super 调用,以创建并初始化具有 [[StringData]] 内部槽的子类实例。此函数在调用时执行以下步骤:
String
此函数可以用任意数量的参数调用,这些参数组成了剩余参数 codeUnits。
调用时,它执行以下步骤:
此函数的
此函数可以用任意数量的参数调用,这些参数组成了剩余参数 codePoints。
调用时,它执行以下步骤:
此函数的
String.prototype 的初始值是
此属性的特性为 { [[Writable]]:
此函数可以用可变数量的参数调用。第一个参数是 template,其余参数组成了
调用时,它执行以下步骤:
此函数旨在用作标记模板的标签函数(
String 原型对象:
除非另有明确说明,否则下面定义的 String 原型对象的方法不是通用的,传递给它们的
此方法返回一个单一元素的字符串,包含从将此对象转换为字符串后的值的索引 pos 处的代码单元。如果该索引处没有元素,结果是空字符串。结果
如果 pos 是一个 x.charAt(pos)
的结果等同于 x.substring(pos, pos + 1) 的结果。
此方法在调用时执行以下步骤:
此方法故意是通用的;它不要求其
此方法返回一个数字(一个非负的
此方法在调用时执行以下步骤:
此方法故意是通用的;它不要求其
此方法在调用时执行以下步骤:
此方法故意是通用的;它不要求其
当调用此方法时,它返回一个由
调用此方法时执行以下步骤:
此方法的
此方法具有通用性;它不要求其
String.prototype.constructor 的初始值是
调用此方法时执行以下步骤:
如果将 searchString 转换为字符串的代码单元序列与该对象(转换为字符串)在 endPosition - length(this)
处的相应代码单元序列相同,则此方法返回
如果第一个参数是 RegExp,则抛出异常的规定是为了允许将来版本定义扩展,允许这样的参数值。
此方法具有通用性;它不要求其
调用此方法时执行以下步骤:
如果 searchString 作为一个
如果第一个参数是 RegExp,则抛出异常的规定是为了允许将来版本定义扩展,允许这样的参数值。
此方法具有通用性;它不要求其
如果 searchString 作为一个
调用此方法时执行以下步骤:
此方法具有通用性;它不要求其
调用此方法时执行以下步骤:
如果 searchString 作为一个
调用此方法时执行以下步骤:
此方法有意是通用的;它不要求其
一个包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 规范实现此方法。如果 ECMAScript 实现不包含 ECMA-402 API,则使用以下规范来实现此方法:
此方法返回一个除
在执行比较之前,此方法执行以下步骤以准备字符串:
此方法的第二和第三个参数的含义在 ECMA-402 规范中定义;不包含 ECMA-402 支持的实现不得对这些参数位置赋予任何其他解释。
实际的返回值是
此方法本身不适合作为 Array.prototype.sort 的参数,因为后者要求一个具有两个参数的函数。
此方法可能依赖于 ECMAScript 环境中来自
// Å ANGSTROM SIGN vs.
// Å LATIN CAPITAL LETTER A + COMBINING RING ABOVE
"\u212B".localeCompare("A\u030A")
// Ω OHM SIGN vs.
// Ω GREEK CAPITAL LETTER OMEGA
"\u2126".localeCompare("\u03A9")
// ṩ LATIN SMALL LETTER S WITH DOT BELOW AND DOT ABOVE vs.
// ṩ LATIN SMALL LETTER S + COMBINING DOT ABOVE + COMBINING DOT BELOW
"\u1E69".localeCompare("s\u0307\u0323")
// ḍ̇ LATIN SMALL LETTER D WITH DOT ABOVE + COMBINING DOT BELOW vs.
// ḍ̇ LATIN SMALL LETTER D WITH DOT BELOW + COMBINING DOT ABOVE
"\u1E0B\u0323".localeCompare("\u1E0D\u0307")
// 가 HANGUL CHOSEONG KIYEOK + HANGUL JUNGSEONG A vs.
// 가 HANGUL SYLLABLE GA
"\u1100\u1161".localeCompare("\uAC00")
有关规范等价性的定义和讨论,请参见 Unicode 标准第 2 章和第 3 章,以及 Unicode 标准附录 #15,Unicode 规范化形式 和 Unicode 技术说明 #5,应用中的规范等价性。还请参见 Unicode 技术标准 #10,Unicode 排序算法。
建议此方法不应遵守 Unicode 兼容等价或兼容分解,如 Unicode 标准第 3 章第 3.7 节中定义的。
此方法有意是通用的;它不要求其
当调用此方法时,它执行以下步骤:
此方法有意是通用的;它不要求其
此方法对表示
当调用此方法时,它执行以下步骤:
String.prototype.split 类似,String.prototype.matchAll
设计时通常不修改其输入。当调用此方法时,它执行以下步骤:
此方法有意是通用的;它不要求其
当调用此方法时,它执行以下步骤:
当调用此方法时,它执行以下步骤:
抽象操作 StringPaddingBuiltinsImpl 接受参数 O(一个
抽象操作 StringPad 接受参数 S(一个字符串)、maxLength(一个非负的
参数 maxLength 会被限制,使其不小于 S 的长度。
参数 fillString 默认为
抽象操作 ToZeroPaddedDecimalString 接受参数 n(一个非负的
当调用此方法时,它执行以下步骤:
此方法创建一个字符串,该字符串由
此方法具有通用性;它不要求其
调用此方法时,会执行以下步骤:
此方法是有意设计为通用的;它不要求其
抽象操作 GetSubstitution 接受以下参数:matched(一个字符串),str(一个字符串),position(一个非负的
术语 十进制数字 是从 0x0030(数字零)到 0x0039(数字九)的代码单元。对于字母的拼写可以参考 [ECMA-262][https://www.ecma-international.org/en-GB/standards/ecma-262/]
当调用此方法时,它执行以下步骤:
当调用此方法时,它执行以下步骤:
此方法有意设计为通用的;它不要求其
此方法返回将该对象转换为字符串后,从索引 start 开始到索引 end(不包括 end 索引,或者如果 end 为
当调用此方法时,它执行以下步骤:
此方法有意设计为通用的;它不要求其
该方法返回一个数组,其中包含将转换为字符串的对象的子串。子串是通过从左到右搜索separator的出现位置来确定的,这些出现位置不属于返回数组中的任何字符串,而是用来划分字符串值。separator的值可以是任意长度的字符串,或具有
调用时执行以下步骤:
separator的值可以是空字符串。在这种情况下,separator不会匹配输入字符串开头或结尾的空
如果
如果separator是
该方法有意是通用的;它不要求其
当调用时,该方法执行以下步骤:
如果将 searchString 转换为字符串后的代码单元序列与该对象(转换为字符串)从索引 position 开始的对应代码单元序列相同,则此方法返回
如果第一个参数是 RegExp,则抛出异常是为了允许未来版本定义允许这种参数值的扩展。
该方法有意是通用的;它不要求其
此方法返回将此对象转换为字符串的结果的一个
如果任一参数是
如果 start 严格大于 end,则交换它们。
调用时执行以下步骤:
该方法有意是通用的;它不要求其
一个包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 规范中的规定来实现此方法。如果 ECMAScript 实现不包含 ECMA-402 API,则使用以下规范:
该方法将字符串值解释为 UTF-16 编码的代码点序列,如
它的工作方式与 toLowerCase 完全相同,只是它旨在产生符合
此方法的可选参数的含义在 ECMA-402 规范中定义;不包含 ECMA-402 支持的实现不得将这些参数位置用于其他目的。
该方法有意是通用的;它不要求其
一个包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 规范中的规定来实现此方法。如果 ECMAScript 实现不包含 ECMA-402 API,则使用以下规范:
该方法将字符串值解释为 UTF-16 编码的代码点序列,如
它的工作方式与 toUpperCase 完全相同,只是它旨在产生符合
此方法的可选参数的含义在 ECMA-402 规范中定义;不包含 ECMA-402 支持的实现不得将这些参数位置用于其他目的。
该方法有意是通用的;它不要求其
此方法将字符串值解释为 UTF-16 编码的代码点序列,如
调用时执行以下步骤:
结果必须根据 Unicode 字符数据库中的区域无关大小写映射生成(这明确包括不仅仅是文件 UnicodeData.txt,还包括伴随的文件
SpecialCasing.txt
中所有区域无关的映射)。
某些代码点的大小写映射可能产生多个代码点。在这种情况下,结果字符串的长度可能与源字符串不同。由于 toUpperCase 和 toLowerCase
都具有上下文敏感行为,因此这些方法并不对称。换句话说,s.toUpperCase().toLowerCase() 不一定等于
s.toLowerCase()。
该方法有意是通用的;它不要求其
调用此方法时执行以下步骤:
对于 String 对象,此方法恰好返回与 valueOf 方法相同的结果。
此方法将字符串值解释为 UTF-16 编码的代码点序列,如
它的行为与 String.prototype.toLowerCase 完全相同,只不过字符串使用 Unicode 默认大小写转换算法中的 toUppercase 算法进行映射。
该方法有意是通用的;它不要求其
此方法返回一个字符串表示形式,其中所有未构成有效
调用时执行以下步骤:
此方法将字符串值解释为一系列 UTF-16 编码的代码点,如
调用时执行以下步骤:
此方法故意设计得很通用;它不要求其
抽象操作 `TrimString` 接受参数 string(一个
空白的定义是
此方法将字符串值解释为一系列 UTF-16 编码的代码点,如
调用时执行以下步骤:
此方法故意设计得很通用;它不要求其
此方法将字符串值解释为一系列 UTF-16 编码的代码点,如
调用时执行以下步骤:
此方法故意设计得很通用;它不要求其
当调用此方法时,执行以下步骤:
抽象操作 `ThisStringValue` 接受参数 value(一个
此方法返回一个迭代器对象(
当调用此方法时,执行以下步骤:
此方法的
字符串实例是
字符串实例具有一个
表示此字符串对象所代表的字符串值中的元素数量。
一旦字符串对象被初始化,此属性将保持不变。它的属性为 { [[Writable]]:
字符串迭代器是一个对象,表示对某个特定字符串实例对象的特定迭代。字符串迭代器对象没有一个命名的
%StringIteratorPrototype% 对象:
该属性的属性为 { [[Writable]]:
一个 RegExp 对象包含一个正则表达式及其关联的标志。
正则表达式的形式和功能是模仿 Perl 5 编程语言中的正则表达式功能。
RegExp
每个 \u u
\u
这里的前两行等同于字符类。
本节中的许多生成式在
本节在
PropertyValueAliases.txt中列出的Unicode属性或属性别名。
PropertyValueAliases.txt中列出的,也不是二进制属性或二进制属性别名,列在抽象操作 CountLeftCapturingParensWithin 接受参数 node(一个 (模式字符。
本节在
调用时执行以下步骤:
抽象操作 CountLeftCapturingParensBefore 接受参数 node(一个
本节在
调用时执行以下步骤:
本节在
它在以下生成式中分段定义:
“
本节在
它在以下生成式中分段定义:
本节在
它在以下生成式中分段定义:
| ControlEscape | 数值 | 代码点 | Unicode 名称 | 符号 |
|---|---|---|---|---|
t |
9 | U+0009 |
CHARACTER TABULATION | <HT> |
n |
10 | U+000A |
LINE FEED (LF) | <LF> |
v |
11 | U+000B |
LINE TABULATION | <VT> |
f |
12 | U+000C |
FORM FEED (FF) | <FF> |
r |
13 | U+000D |
CARRIAGE RETURN (CR) | <CR> |
\0表示<NUL>字符,且不能后跟十进制数字。
抽象操作 GroupSpecifiersThatMatch 接受参数 thisGroupName(一个
正则表达式模式使用下面描述的过程转换为一个
如果一个 u 或 v,则它是一个 BMP 模式。否则,它是一个 Unicode 模式。BMP 模式与解释为由一系列 16 位值组成的字符串匹配,这些值是 Unicode
基本多文种平面的代码点。Unicode 模式与解释为由使用 UTF-16 编码的 Unicode 代码点组成的字符串匹配。在描述 BMP 模式行为的上下文中,“字符”指单个 16 位的 Unicode BMP
代码点。在描述 Unicode 模式行为的上下文中,“字符”指一个 UTF-16 编码的代码点 (
例如,考虑一个源文本表示为单个非 BMP 字符 U+1D11E(音乐符号 G 谱号)的模式。解释为 Unicode 模式时,它将是一个单元素(字符)
模式作为 ECMAScript 字符串值传递给 RegExp
实现实际上可能不会执行这样的 UTF-16 翻译,但本规范的语义要求模式匹配的结果好像进行了这样的翻译。
下面的描述使用以下内部数据结构:
RegExp 记录 是一个
它具有以下字段:
本节在
它根据以下规则分段定义:
| 正则表达式运算符分隔两个替代项。模式首先尝试匹配左边的
| 跳过部分中的捕获括号都会生成
/a|ab/.exec("abc")
返回结果
/((a)|(ab))((c)|(bc))/.exec("abc")
返回数组
["abc", "a", "a", undefined, "bc", undefined, "bc"]
而不是
["abc", "ab", undefined, "ab", "c", "c", undefined]
两个替代项的尝试顺序与 direction 的值无关。
连续的
生成的
抽象操作 RepeatMatcher 接受参数 m(一个
一个
如果
比较
/a[a-z]{2,4}/.exec("abcdefghi")
返回
/a[a-z]{2,4}?/.exec("abcdefghi")
返回
考虑还包括
/(aa|aabaac|ba|b|c)*/.exec("aabaac")
按上述选择点顺序返回数组
["aaba", "ba"]
而不是以下任一项:
["aabaac", "aabaac"]
["aabaac", "c"]
上述选择点顺序可用于编写一个正则表达式来计算两个数字的最大公约数(以一进制表示)。以下示例计算 10 和 15 的 gcd:
"aaaaaaaaaa,aaaaaaaaaaaaaaa".replace(/^(a+)\1*,\1+$/, "$1")
以一进制表示返回 gcd
RepeatMatcher 的步骤
/(a*)*/.exec("b")
或者稍微复杂一点:
/(a*)b1+/.exec("baaaac")
返回数组
["b", ""]
抽象操作 EmptyMatcher 不接受任何参数,并返回一个
抽象操作 MatchTwoAlternatives 接受参数 m1(一个
抽象操作 MatchSequence 接受参数 m1(一个
语法定向操作 CompileAssertion 接受参数 rer(一个
此部分在
它按以下产生式逐段定义:
即使使用 y 标志,^ 也只匹配 Input 的开头,或者(如果 rer.[[Multiline]] 为
形式 (?= )
指定零宽正前瞻。为了成功,(?= 形式(这种不寻常的行为继承自 Perl)。这仅在
例如,
/(?=(a+))/.exec("baaabac")
在第一个 b 后立即匹配空字符串,因此返回数组:
["", "aaa"]
为了说明缺少回溯到前瞻,考虑:
/(?=(a+))a*b\1/.exec("baaabac")
此表达式返回
["aba", "a"]
而不是:
["aaaba", "a"]
形式 (?! )
指定零宽负前瞻。为了成功,
/(.*?)a(?!(a+)b\2c)\2(.*)/.exec("baaabaac")
查找不紧跟某个正数 a 的 a,b,另一个 n a(由第一个
\2 指定)和一个 c。第二个 \2 在负前瞻之外,因此匹配
["baaabaac", "ba", undefined, "abaac"]
抽象操作 IsWordChar 接受参数 rer(一个
语法导向操作
语法导向操作
语法导向操作
本节在
它通过以下产生式逐段定义:
形式为 ( ) 的括号既用于将
\ 后跟一个非零十进制数)、替换字符串中引用或作为数组的一部分从正则表达式匹配的 (?: ) 代替。
形式为 \ 后跟非零十进制数 n 的转义序列匹配第 n 组捕获括号的结果(
抽象操作字符集匹配器接受参数 rer (一个
抽象操作 BackreferenceMatcher 接受参数 rer (一个
抽象操作 Canonicalize 接受参数 rer (一个
CaseFolding.txt
文件为 ch 提供了一个简单或常见的大小写折叠映射,返回应用该映射到 ch 的结果。
在大小写不敏感的匹配中,当 ß (U+00DF 德语小写字母尖S) 映射为 ss 或
SS。然而,它可能会将基本拉丁语块之外的代码点映射到其中的代码点,例如,ſ (U+017F 拉丁小写长S) 会大小写折叠为
s
(U+0073 拉丁小写字母S),K (U+212A 开尔文符号) 会大小写折叠为 k (U+006B
拉丁小写字母K)。包含这些代码点的字符串可以被正则表达式如 /[a-z]/ui 匹配。
在大小写不敏感的匹配中,当 Ω (U+2126 欧姆符号) 被 toUppercase 映射为其本身,但被 toCasefold 映射为
ω (U+03C9 希腊小写字母欧米茄) 和 Ω (U+03A9 希腊大写字母欧米茄),因此 /[ω]/ui 和 /[\u03A9]/ui 匹配,但不能被 /[ω]/i 或
/[\u03A9]/i 匹配。此外,没有代码点会从基本拉丁语块外映射到其中的代码点,因此像 /[a-z]/i 匹配。
本节在
它通过以下生成规则分段定义:
即使模式忽略大小写,范围两端的大小写在确定哪些字符属于范围时也很重要。因此,例如,模式 /[E-F]/i 仅匹配字母
E、F、e 和 f,而模式 /[E-f]/i 匹配 Unicode
基本拉丁字母块中的所有大写和小写字母,以及符号 [、\、]、^、_ 和
`。
- 字符可以被视为字面意思或表示范围。如果它是
- U+002D (HYPHEN-MINUS) 的 一个 \b、\B 和反向引用。在 \b
表示退格字符,而 \B 和反向引用会引发错误。在
0、1、2、3、4、5、6、7、8
和 9 的十元素 General_Category, s)
是 General_Category (gc) 属性的 Unicode 属性值或属性值别名,列在
PropertyValueAliases.txt
中,则:
结果通常会包含两个或更多的范围。当 UnicodeSets 为
抽象操作 CharacterRange 接受参数 A(一个
抽象操作 HasEitherUnicodeFlag 接受参数 rer(一个
抽象操作 WordCharacters 接受参数 rer(一个 \b、\B、\w 和 \W。调用时执行以下步骤:
抽象操作 AllCharacters 接受参数 rer(一个
抽象操作 MaybeSimpleCaseFolding 接受两个参数:rer(一个 CaseFolding.txt
文件中(每个映射将一个代码点映射到另一个代码点)逐字符地将 A 的每个
抽象操作 CharacterComplement 接受两个参数:rer(一个
抽象操作 UnicodeMatchProperty 接受两个参数:rer(一个
实现必须支持在
例如,Script_Extensions(scx(属性别名)是有效的,但 script_extensions 或
Scx 不是。
列出的属性组成了 UTS18 RL1.2 所要求的超集。
这些表格中的条目的拼写(包括大小写)与 Unicode 字符数据库中的文件 PropertyAliases.txt
中使用的拼写匹配。该文件中的精确拼写是 保证稳定的。
| 标准化 |
|
|---|---|
General_Category |
General_Category
|
gc |
|
Script |
Script
|
sc |
|
Script_Extensions |
Script_Extensions
|
scx |
| 标准化 |
|
|---|---|
ASCII |
ASCII
|
ASCII_Hex_Digit |
ASCII_Hex_Digit
|
AHex |
|
Alphabetic |
Alphabetic |
Alpha |
|
Any |
Any
|
Assigned |
Assigned
|
Bidi_Control |
Bidi_Control
|
Bidi_C |
|
Bidi_Mirrored |
Bidi_Mirrored
|
Bidi_M |
|
Case_Ignorable |
Case_Ignorable
|
CI |
|
Cased |
Cased |
Changes_When_Casefolded |
Changes_When_Casefolded
|
CWCF |
|
Changes_When_Casemapped |
Changes_When_Casemapped
|
CWCM |
|
Changes_When_Lowercased |
Changes_When_Lowercased
|
CWL |
|
Changes_When_NFKC_Casefolded |
Changes_When_NFKC_Casefolded
|
CWKCF |
|
Changes_When_Titlecased |
Changes_When_Titlecased
|
CWT |
|
Changes_When_Uppercased |
Changes_When_Uppercased
|
CWU |
|
Dash |
Dash |
Default_Ignorable_Code_Point |
Default_Ignorable_Code_Point
|
DI |
|
Deprecated |
Deprecated |
Dep |
|
Diacritic |
Diacritic
|
Dia |
|
Emoji |
Emoji
|
Emoji_Component |
Emoji_Component
|
EComp |
|
Emoji_Modifier |
Emoji_Modifier
|
EMod |
|
Emoji_Modifier_Base |
Emoji_Modifier_Base
|
EBase |
|
Emoji_Presentation |
Emoji_Presentation
|
EPres |
|
Extended_Pictographic |
Extended_Pictographic
|
ExtPict |
|
Extender |
Extender
|
Ext |
|
Grapheme_Base |
Grapheme_Base
|
Gr_Base |
|
Grapheme_Extend |
Grapheme_Extend
|
Gr_Ext |
|
Hex_Digit |
Hex_Digit
|
Hex |
|
IDS_Binary_Operator |
IDS_Binary_Operator
|
IDSB |
|
IDS_Trinary_Operator |
IDS_Trinary_Operator
|
IDST |
|
ID_Continue |
ID_Continue |
IDC |
|
ID_Start |
ID_Start
|
IDS |
|
Ideographic |
Ideographic |
Ideo |
|
Join_Control |
Join_Control
|
Join_C |
|
Logical_Order_Exception |
Logical_Order_Exception
|
LOE |
|
Lowercase |
Lowercase
|
Lower |
|
Math |
Math |
Noncharacter_Code_Point |
Noncharacter_Code_Point
|
NChar |
|
Pattern_Syntax |
Pattern_Syntax
|
Pat_Syn |
|
Pattern_White_Space |
Pattern_White_Space
|
Pat_WS |
|
Quotation_Mark |
Quotation_Mark
|
QMark |
|
Radical |
Radical |
Regional_Indicator |
Regional_Indicator
|
RI |
|
Sentence_Terminal |
Sentence_Terminal |
STerm |
|
Soft_Dotted |
Soft_Dotted |
SD |
|
Terminal_Punctuation |
Terminal_Punctuation
|
Term |
|
Unified_Ideograph |
Unified_Ideograph
|
UIdeo |
|
Uppercase |
Uppercase
|
Upper |
|
Variation_Selector |
Variation_Selector
|
VS |
|
White_Space |
White_Space |
space |
|
XID_Continue |
XID_Continue
|
XIDC |
|
XID_Start |
XID_Start
|
XIDS |
Basic_Emoji |
Emoji_Keycap_Sequence |
RGI_Emoji_Modifier_Sequence |
RGI_Emoji_Flag_Sequence |
RGI_Emoji_Tag_Sequence |
RGI_Emoji_ZWJ_Sequence |
RGI_Emoji |
抽象操作 UnicodeMatchPropertyValue 接受两个参数 p (
实现必须支持 PropertyValueAliases.txt
中列出的 Unicode 属性值和属性值别名,针对在
例如,Xpeo 和 Old_Persian 是有效的 Script_Extensions 值,但
xpeo 和 Old Persian 不是。
此算法与 UAX44 中列出的符号值匹配规则
有所不同:不忽略大小写、Is 前缀。
抽象操作 RegExpCreate 接受参数 P(一个
抽象操作 RegExpAlloc 接受参数 newTarget(一个
抽象操作 RegExpInitialize 接受参数 obj(一个对象),
pattern
(一个
抽象操作 ParsePattern 接受参数 patternText(一个 Unicode 代码点序列),u(一个布尔值),和
v(一个布尔值),返回一个
本节在
它在调用时执行以下步骤:
RegExp
extends 子句的值。继承指定 RegExp 行为的子类 super 调用,以使用必要的内部槽来创建和初始化子类实例。
此函数在调用时执行以下步骤:
如果使用
RegExp
RegExp.prototype 的初始值是
此属性具有属性 { [[Writable]]:
RegExp[@@species] 是一个
此函数的
RegExp 原型对象:
RegExp 原型对象没有自己的
RegExp.prototype.constructor 的初始值是
此方法在 string 中搜索正则表达式模式的出现,并返回包含匹配结果的数组,或者如果 string 未匹配,则返回
它在调用时执行以下步骤:
RegExp.prototype.dotAll 是一个
RegExp.prototype.flags 是一个
抽象操作 RegExpHasFlag 接受参数 R(一个
RegExp.prototype.global 是一个
RegExp.prototype.hasIndices 是一个
RegExp.prototype.ignoreCase 是一个
此方法在调用时执行以下步骤:
此方法的
此方法在调用时执行以下步骤:
此方法的
RegExp.prototype.multiline 是一个
此方法在调用时执行以下步骤:
此方法的
调用此方法时执行以下步骤:
此方法的
在执行搜索时,会忽略此 RegExp 对象的
RegExp.prototype.source 是一个
抽象操作 EscapeRegExpPattern 接受参数 P(一个字符串)和 F(一个字符串),并返回一个字符串。调用时执行以下步骤:
/ 或任何 ///
后跟 F 将被解析为 该方法返回一个数组,其中存储了将 string 转换为字符串后的子字符串。这些子字符串是通过从左到右搜索
/a*?/[Symbol.split]("ab") 的计算结果为数组
["a", "b"],而 /a*/[Symbol.split]("ab") 的计算结果为数组 ["","b"]。)
如果 string 是(或转换为)空字符串,结果取决于正则表达式是否可以匹配空字符串。如果可以,则结果数组不包含任何元素。否则,结果数组包含一个元素,即空字符串。
如果正则表达式包含捕获括号,则每次匹配 separator 时,捕获括号的结果(包括任何
/<(\/)?([^<>]+)>/[Symbol.split]("A<B>bold</B>and<CODE>coded</CODE>")
计算结果为数组
["A", undefined, "B", "bold", "/", "B", "and", undefined, "CODE", "coded", "/", "CODE", ""]
如果 limit 不是
调用该方法时执行以下步骤:
该方法的
该方法忽略此 RegExp 对象的
RegExp.prototype.sticky 是一个
调用此方法时执行以下步骤:
返回的字符串形式为
RegExp.prototype.unicode 是一个
RegExp.prototype.unicodeSets 是一个
抽象操作 RegExpExec 接受参数 R(一个对象)和 S(一个字符串),并返回包含对象或
如果找不到可调用的
抽象操作 RegExpBuiltinExec 接受参数 R(一个已初始化的 RegExp 实例)和 S(一个字符串),并返回包含
抽象操作 AdvanceStringIndex 接受参数 S(一个字符串),index(一个非负整数),和 unicode(一个布尔值),并返回一个整数。调用时执行以下步骤:
抽象操作 GetStringIndex 接受参数 S(一个字符串)和 codePointIndex(一个非负整数),并返回一个非负整数。它将 S
解释为 UTF-16 编码的代码点序列,如
匹配记录 是一个
匹配记录包含
抽象操作 GetMatchString 接受参数 S(一个字符串)和 match(一个
抽象操作 GetMatchIndexPair 接受参数 S(一个字符串)和 match(一个
抽象操作 MakeMatchIndicesIndexPairArray 接受参数 S(一个字符串)、indices(一个包含
RegExp 实例是
RegExp 实例还具有以下属性:
RegExp 字符串迭代器是一个对象,它表示某个特定的 RegExp 实例对象与某个特定的字符串实例对象匹配时的特定迭代。RegExp 字符串迭代器对象没有命名的
抽象操作 CreateRegExpStringIterator 接受参数 R(一个对象)、S(一个字符串)、global(一个布尔值)和 fullUnicode(一个布尔值),并返回一个生成器。调用时执行以下步骤:
%RegExpStringIteratorPrototype% 对象:
此属性的特性为 { [[Writable]]:
数组是一种特殊对待某类属性名称的
数组构造函数
Array(…)
等同于对象创建表达式 new Array(…),使用相同的参数。extends 子句的值。意图继承异类数组行为的子类 super 调用,以初始化作为
Array.prototype 方法都是通用方法,不依赖于它们的 当调用此函数时,执行以下步骤:
数组构造函数
调用此方法时执行以下步骤:
调用此函数时执行以下步骤:
调用此方法时执行以下步骤:
Array.prototype 的值是
此属性具有以下特性:{ [[Writable]]:
Array[@@species] 是一个
此函数的
Array 原型对象:
Array 原型对象被指定为
此方法返回一个数组,其中包含对象的数组元素,后跟每个参数的数组元素。
调用时执行以下步骤:
此方法的
在步骤
此方法有意是通用的;它不要求其
抽象操作 IsConcatSpreadable 接受参数 O(一个
Array.prototype.constructor 的初始值是
end 参数是可选的。如果未提供,则使用
如果 target 为负数,则将其视为
调用此方法时执行以下步骤:
此方法有意是通用的;它不要求其
调用此方法时执行以下步骤:
callbackfn 应该是一个接受三个参数并返回一个可强制转换为布尔值的值的函数。every 按升序依次为数组中的每个元素调用
callbackfn,直到找到一个 callbackfn 返回 every 立即返回 every 将返回
如果提供了 thisArg 参数,它将在每次调用 callbackfn 时作为
callbackfn 以三个参数调用:元素的值、元素的索引和正在遍历的对象。
every 不直接改变调用它的对象,但对象可能会因对 callbackfn 的调用而发生变化。
every 处理的元素范围在第一次调用 callbackfn 之前就已确定。在 every 调用开始后添加到数组的元素不会被
callbackfn 访问。如果数组的现有元素发生变化,它们传递给 callbackfn 的值将是 every 访问它们时的值;在调用
every 开始后删除的元素在访问前不会被访问。every 类似于数学中的“对所有”量词。特别是,对于一个空数组,它返回
调用此方法时执行以下步骤:
此方法有意是通用的;它不要求其
start 参数是可选的。如果未提供,则使用
end 参数是可选的。如果未提供,则使用
如果 start 为负数,则将其视为
调用此方法时执行以下步骤:
此方法有意是通用的;它不要求其
callbackfn 应该是一个接受三个参数并返回一个可强制转换为布尔值的值的函数。filter 按升序依次为数组中的每个元素调用
callbackfn,并构建一个由 callbackfn 返回
如果提供了 thisArg 参数,它将在每次调用 callbackfn 时作为
callbackfn 以三个参数调用:元素的值、元素的索引和正在遍历的对象。
filter 不直接改变调用它的对象,但对象可能会因对 callbackfn 的调用而发生变化。
filter 处理的元素范围在第一次调用 callbackfn 之前就已确定。在 filter 调用开始后添加到数组的元素不会被
callbackfn 访问。如果数组的现有元素发生变化,它们传递给 callbackfn 的值将是 filter
访问它们时的值;在调用 filter 开始后删除的元素在访问前不会被访问。
调用此方法时执行以下步骤:
此方法有意是通用的;它不要求其
此方法按升序索引顺序为数组的每个元素调用一次 predicate,直到找到一个 predicate 返回一个可强制转换为
find 立即返回该元素值。否则,find 返回
有关更多信息,请参阅
调用此方法时执行以下步骤:
此方法有意是通用的;它不要求其
此方法按升序索引顺序为数组的每个元素调用一次 predicate,直到找到一个 predicate 返回一个可强制转换为
findIndex 立即返回该元素值的索引。否则,findIndex
返回 -1。
有关更多信息,请参阅
调用此方法时执行以下步骤:
此方法有意是通用的;它不要求其
此方法按降序索引顺序为数组的每个元素调用一次 predicate,直到找到一个 predicate 返回一个可强制转换为
findLast 立即返回该元素值。否则,findLast 返回
有关更多信息,请参阅
调用此方法时执行以下步骤:
此方法有意是通用的;它不要求其
此方法按降序索引顺序为数组的每个元素调用一次 predicate,直到找到一个 predicate 返回一个可强制转换为
findLastIndex
立即返回该元素值的索引。否则,findLastIndex 返回 -1。
有关更多信息,请参阅
调用此方法时执行以下步骤:
此方法有意是通用的;它不要求其
抽象操作 FindViaPredicate 接受参数
O(一个对象)、len(一个非负整数)、direction(
O 应该是一个
predicate 应该是一个函数。当为数组的一个元素调用时,它会传递三个参数:元素的值、元素的索引和正在遍历的对象。其返回值将被强制转换为布尔值。
thisArg 将作为每次调用 predicate 时的
此操作不会直接修改其被调用的对象,但该对象可能会被对 predicate 的调用修改。
在第一次调用 predicate 之前、遍历开始之前会设置处理的元素范围。此后添加到数组的元素将不会被 predicate
访问。如果数组的现有元素发生变化,它们作为传递给 predicate 的值将是此操作访问它们时的值。遍历开始后删除的元素仍然会被访问,并且要么从原型中查找,要么是
调用此操作时执行以下步骤:
调用此方法时执行以下步骤:
抽象操作 FlattenIntoArray 接受参数 target(一个对象)、source(一个对象)、sourceLen(一个非负整数)、start(一个非负整数)和 depth(一个非负整数或 +∞),以及可选参数 mapperFunction(一个函数对象)和 thisArg(一个 ECMAScript 语言值),并返回一个包含非负整数的正常完成记录或一个抛出完成记录。调用时执行以下步骤:
调用此方法时执行以下步骤:
callbackfn 应该是一个接受三个参数的函数。forEach 会为数组中存在的每个元素调用一次
callbackfn,按升序调用。callbackfn 只会被调用数组中实际存在的元素;对于数组中缺失的元素不会调用。
如果提供了 thisArg 参数,它将在每次调用 callbackfn 时作为
callbackfn 被调用时传递三个参数:元素的值、元素的索引和被遍历的对象。
forEach 不会直接改变调用它的对象,但对象可能会被 callbackfn 的调用改变。
forEach 处理的元素范围在首次调用 callbackfn 前设置。在调用 forEach 开始后追加到数组的元素不会被
callbackfn 访问。如果数组中的现有元素被更改,它们在 forEach 访问它们时的值将是 callbackfn
访问它们时的值;在调用 forEach 开始后且在访问之前被删除的元素不会被访问。
调用此方法时执行以下步骤:
此方法是有意泛化的;它不要求其
此方法使用
可选的第二个参数 fromIndex 默认值为
调用此方法时执行以下步骤:
此方法是有意泛化的;它不要求其
此方法有意与类似的 indexOf 方法在两个方面不同。首先,它使用
此方法使用
可选的第二个参数 fromIndex 默认值为
调用此方法时执行以下步骤:
此方法是有意泛化的;它不要求其
此方法将数组的元素转换为字符串,然后将这些字符串连接起来,以 separator 为分隔符。如果未提供分隔符,则使用单个逗号作为分隔符。
调用此方法时执行以下步骤:
此方法是有意泛化的;它不要求其
调用此方法时执行以下步骤:
此方法使用
可选的第二个参数 fromIndex 默认为数组的长度减去一(即搜索整个数组)。如果它大于或等于数组的长度,将搜索整个数组。如果它小于
调用此方法时执行以下步骤:
此方法是故意通用的;它不要求其
callbackfn 应是一个接受三个参数的函数。map 按升序依次调用
callbackfn,并从结果中构建一个新的数组。callbackfn 只对数组中实际存在的元素调用,不对数组中缺失的元素调用。
如果提供了 thisArg 参数,则将在每次调用 callbackfn 时使用它作为
callbackfn 调用时会接受三个参数:元素的值、元素的索引和被遍历的对象。
map 不会直接改变调用它的对象,但该对象可能会被 callbackfn 的调用所改变。
map 处理的元素范围在第一次调用 callbackfn 之前确定。在调用 map 之后添加到数组中的元素不会被
callbackfn 访问。如果数组中的现有元素发生更改,它们在 callbackfn 访问时的值将是 map 访问它们时的值;在调用
map 之后并在访问之前删除的元素不会被访问。
调用此方法时执行以下步骤:
此方法是故意通用的;它不要求其
此方法移除数组的最后一个元素并返回它。
调用此方法时执行以下步骤:
此方法是故意通用的;它不要求其
此方法将参数按出现顺序追加到数组的末尾。它返回数组的新长度。
调用此方法时执行以下步骤:
此方法的
此方法是故意通用的;它不要求其
callbackfn 应该是一个接受四个参数的函数。reduce 按升序依次调用 callbackfn,从数组的第一个元素开始。
callbackfn 用四个参数调用:previousValue(来自前一次 callbackfn
调用的值),currentValue(当前元素的值),currentIndex,以及被遍历的对象。第一次调用 callbackfn
时,previousValue 和 currentValue 可能有两种值。如果在调用 reduce 时提供了
initialValue,那么 previousValue 将是 initialValue,而
currentValue 将是数组的第一个值。如果没有提供 initialValue,那么 previousValue
将是数组的第一个值,currentValue 将是第二个值。如果数组为空且未提供 initialValue,将抛出
reduce 不直接改变调用它的对象,但该对象可能会被 callbackfn 的调用所修改。
reduce 处理的元素范围在第一次调用 callbackfn 之前确定。在调用 reduce 开始后添加到数组中的元素不会被
callbackfn 访问。如果在调用 reduce 期间更改了现有元素,则传递给 callbackfn 的值将是
reduce 访问它们时的值;在调用 reduce 开始后删除的元素且未被访问的元素不会被访问。
调用此方法时执行以下步骤:
此方法是故意通用的;它不要求其
callbackfn 应该是一个接受四个参数的函数。reduceRight 以降序遍历数组中每个元素,从第二个元素开始,依次调用
callbackfn。
callbackfn 用四个参数调用:previousValue(来自前一次 callbackfn
调用的值),currentValue(当前元素的值),currentIndex,以及被遍历的对象。第一次调用 callbackfn
时,previousValue 和 currentValue 可能有两种值。如果在调用 reduceRight 时提供了
initialValue,那么 previousValue 将是 initialValue,而
currentValue 将是数组的最后一个值。如果没有提供 initialValue,那么 previousValue
将是数组的最后一个值,currentValue 将是倒数第二个值。如果数组为空且未提供 initialValue,将抛出
reduceRight 不直接改变调用它的对象,但该对象可能会被 callbackfn 的调用所修改。
reduceRight 处理的元素范围在第一次调用 callbackfn 之前确定。在调用 reduceRight
开始后添加到数组中的元素不会被 callbackfn 访问。如果在调用 reduceRight 期间更改了现有元素,则传递给
callbackfn 的值将是 reduceRight 访问它们时的值;在调用 reduceRight
开始后删除的元素且未被访问的元素不会被访问。
调用此方法时执行以下步骤:
此方法故意设计得很通用;它不要求其
此方法重新排列数组中的元素,以反转其顺序。它返回作为调用结果的对象。
调用此方法时执行以下步骤:
此方法故意设计得很通用;它不要求其
此方法移除数组中的第一个元素并返回它。
调用此方法时执行以下步骤:
此方法故意设计得很通用;它不要求其
此方法返回一个数组,该数组包含从元素 start 开始到元素 end 之前的所有元素(如果 end 是
调用时执行以下步骤:
步骤
此方法有意设计为通用的;它不要求其
callbackfn 应该是一个接受三个参数并返回一个可以转换为布尔值的值的函数。some 会对数组中的每一个元素按升序调用
callbackfn,直到找到一个使 callbackfn 返回 some 会立即返回 some 返回
如果提供了 thisArg 参数,它将作为每次调用 callbackfn 的
callbackfn 被调用时会接收三个参数:元素的值、元素的索引和正在遍历的对象。
some 不会直接修改它被调用的对象,但对象可能会被 callbackfn 的调用所修改。
some 处理的元素范围在第一次调用 callbackfn 之前设定。调用 some 后添加到数组中的元素不会被
callbackfn 访问。如果数组中已有的元素被修改,传递给 callbackfn 的值将是 some 访问它们时的值;在
some 调用开始后被删除的元素不会被访问。some 类似于数学中的 "存在" 量词。特别地,对于一个空数组,它返回
此方法在调用时执行以下步骤:
此方法有意设计为通用的;它不要求其
此方法对数组的元素进行排序。排序必须是稳定的(即,比较相等的元素必须保持原来的顺序)。如果 comparefn 不是
调用时执行以下步骤:
由于不存在的属性值总是比
此方法有意地是通用的;它不要求其
抽象操作 SortIndexedProperties 接受以下参数:obj(一个对象)、len(一个非负的
排序顺序 是在完成上述算法的第
除非
这里,符号
如果一个抽象闭包或函数 comparator 对于一组值 S 满足以下所有要求,则它是该组值的 一致的比较器:对所有值 a、b 和 c(可能是相同的值)在集合 S 中:
符号
上述条件是确保 comparator 将集合 S 划分为同值类,并且这些同值类是完全有序的的必要且充分条件。
抽象操作 CompareArrayElements 接受参数 x(一个
此方法删除从
此方法在调用时执行以下步骤:
该方法故意是通用的;它不要求其
包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 规范中规定的方式实现此方法。如果 ECMAScript 实现不包含 ECMA-402 API,则使用以下对该方法的规范。
ECMA-402 的第一版未包含该方法的替代规范。
此方法的可选参数的含义在 ECMA-402 规范中定义;不包含 ECMA-402 支持的实现不得将这些参数位置用于其他目的。
调用此方法时执行以下步骤:
该方法故意是通用的;它不要求其
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
此方法故意是通用的;它不要求其
此方法将参数添加到数组的开头,使得它们在数组中的顺序与在参数列表中的顺序相同。
调用此方法时执行以下步骤:
此方法的
此方法故意是通用的;它不要求其
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
此属性具有以下特性 { [[Writable]]:
该对象的自身属性名是那些在 ECMAScript 2015 规范之前未包含在 Array.prototype 的标准属性名。这些属性名在 with
语句绑定时被忽略,以保留可能使用这些名称作为绑定的现有代码的行为,这些绑定在外部作用域中被 with 语句的绑定对象(数组)所遮蔽。
之所以
数组实例是
数组实例具有一个
数组实例的
数组迭代器是一个对象,表示对某个特定数组实例对象的特定迭代。数组迭代器对象没有命名的
抽象操作 CreateArrayIterator 接受参数 array(一个对象)和
kind(
%ArrayIteratorPrototype% 对象:
此属性具有 { [[Writable]]:
一个 TypedArray 表示底层二进制数据缓冲区的类似数组的视图 (
|
|
元素类型 | 元素大小 | 转换操作 | 描述 |
|---|---|---|---|---|
|
Int8Array %Int8Array% |
|
1 |
|
8 位二进制补码有符号 |
|
Uint8Array %Uint8Array% |
|
1 |
|
8 位无符号 |
|
Uint8ClampedArray %Uint8ClampedArray% |
|
1 |
|
8 位无符号 |
|
Int16Array %Int16Array% |
|
2 |
|
16 位二进制补码有符号 |
|
Uint16Array %Uint16Array% |
|
2 |
|
16 位无符号 |
|
Int32Array %Int32Array% |
|
4 |
|
32 位二进制补码有符号 |
|
Uint32Array %Uint32Array% |
|
4 |
|
32 位无符号 |
|
BigInt64Array %BigInt64Array% |
|
8 |
|
64 位二进制补码有符号 |
|
BigUint64Array %BigUint64Array% |
|
8 |
|
64 位无符号 |
|
Float32Array %Float32Array% |
|
4 | 32 位 IEEE 浮点数 | |
|
Float64Array %Float64Array% |
|
8 | 64 位 IEEE 浮点数 |
在下面的定义中,对 TypedArray 的引用应替换为上述表格中相应的
%TypedArray% 内在对象:
super调用。调用此函数时执行以下步骤:
此函数的
%TypedArray% 内在对象:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
.prototype
的初始值是
该属性具有以下属性:{ [[Writable]]:
[@@species]
是一个
该函数的
%TypedArray% 原型对象:
.prototype.buffer
是一个
.prototype.byteLength
是一个
.prototype.byteOffset
是一个
.prototype.constructor
的初始值是
该方法的参数解释和使用与 Array.prototype.copyWithin 相同,如在
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该方法的参数解释和使用方式与 Array.prototype.every 在
该方法在调用时执行以下步骤:
该方法不是通用的。
该方法的参数解释和使用方式与 Array.prototype.fill 在
该方法在调用时执行以下步骤:
该方法的参数解释和使用方式与 Array.prototype.filter 在
该方法在调用时执行以下步骤:
该方法不是通用的。
该方法的参数解释和使用方式与 Array.prototype.find 在
该方法在调用时执行以下步骤:
该方法不是通用的。
该方法的参数解释和使用方式与 Array.prototype.findIndex 在
该方法在调用时执行以下步骤:
该方法不是通用的。
该方法的参数解释和使用方式与 Array.prototype.findLast 在
该方法在调用时执行以下步骤:
该方法不是通用的。
该方法的参数解释和使用方式与 Array.prototype.findLastIndex 在
该方法在调用时执行以下步骤:
该方法不是通用的。
该方法的参数解释和使用方式与 Array.prototype.forEach 在
该方法在调用时执行以下步骤:
该方法不是通用的。
该方法的参数解释和使用方式与 Array.prototype.includes 在
该方法在调用时执行以下步骤:
该方法不是通用的。
该方法的参数解释和使用方式与 Array.prototype.indexOf 在
该方法在调用时执行以下步骤:
该方法不是通用的。
该方法的参数解释和使用方式与 Array.prototype.join 在
该方法在调用时执行以下步骤:
该方法不是通用的。
该方法在调用时执行以下步骤:
该方法的参数解释和使用方式与 Array.prototype.lastIndexOf 相同,如
该方法在调用时执行以下步骤:
该方法不是通用的。
.prototype.length
是一个
此函数不是通用的。
此方法的参数解释和使用与 Array.prototype.map 相同,如
此方法在调用时执行以下步骤:
此方法不是通用的。
此方法的参数解释和使用与 Array.prototype.reduce 相同,如
此方法在调用时执行以下步骤:
此方法不是通用的。
此方法的参数解释和使用与 Array.prototype.reduceRight 相同,如
此方法在调用时执行以下步骤:
此方法不是通用的。
此方法的参数解释和使用与 Array.prototype.reverse 相同,如
此方法在调用时执行以下步骤:
此方法不是通用的。
此方法在 TypedArray 中设置多个值,从 source 读取值。根据 source 的类型,细节有所不同。可选的 offset 值表示在此 TypedArray 中开始写入值的第一个元素索引。如果省略,则默认为 0。
调用时执行以下步骤:
此方法不是通用的。
抽象操作 SetTypedArrayFromTypedArray 接受以下参数:target(一个
抽象操作 SetTypedArrayFromArrayLike 接受以下参数:target(一个
该方法的参数解释和使用方式与 Array.prototype.slice 相同,如
当调用该方法时,执行以下步骤:
该方法不是通用的。
该方法的参数解释和使用方式与 Array.prototype.some 相同,如
调用该方法时,执行以下步骤:
该方法不是通用的。
这是一个独立的方法,除非下面有所描述,否则实现的要求与 Array.prototype.sort 相同,如
该方法不是通用的。
调用时执行以下步骤:
由于
此方法返回一个新的 TypedArray,其元素类型与当前 TypedArray 的元素类型相同,且其 ArrayBuffer 与当前 TypedArray 的 ArrayBuffer 相同, 引用从 start(含)到 end(不含)之间的元素。如果 start 或 end 为负值,则表示从数组末尾的索引,而不是从开头。
调用时执行以下步骤:
此方法并非通用方法。
这是一个独立的方法,其实现与 Array.prototype.toLocaleString 相同,正如在
此方法并非通用方法。
如果 ECMAScript 实现包括 ECMA-402 国际化 API,则此方法基于 ECMA-402 规范中 Array.prototype.toLocaleString
的算法。
此方法在调用时执行以下步骤:
此方法在调用时执行以下步骤:
属性
此方法在调用时执行以下步骤:
此方法在调用时执行以下步骤:
.prototype[@@toStringTag]
是一个
该属性的特性是 { [[Enumerable]]:
该函数的
抽象操作 TypedArraySpeciesCreate 接受参数 exemplar(一个
抽象操作 TypedArrayCreateFromConstructor 接受参数 constructor(一个
抽象操作 TypedArrayCreateSameType 接受参数 exemplar(一个
抽象操作 ValidateTypedArray 接受参数 O(一个
抽象操作 TypedArrayElementSize 接受参数 O(一个
抽象操作 TypedArrayElementType 接受参数 O(一个
抽象操作 CompareTypedArrayElements 接受参数 x(一个 Number 或 BigInt)、y(一个 Number 或 BigInt)和
comparefn(一个
每个 TypedArray
extends 子句的值。意图继承指定 TypedArray 行为的子类 super
调用,以创建和初始化子类实例,使其具备支持 .prototype
内建方法所需的内部状态。
每个 TypedArray
"%TypedArray.prototype%"。
抽象操作 AllocateTypedArray 接受以下参数:constructorName(一个字符串,表示
抽象操作初始化TypedArray从TypedArray接受参数 O(一个
抽象操作 InitializeTypedArrayFromArrayBuffer 接受参数 O(一个
抽象操作 InitializeTypedArrayFromList 接受参数 O(一个
抽象操作 InitializeTypedArrayFromArrayLike 接受参数 O(一个
抽象操作 AllocateTypedArrayBuffer 接受参数 O(一个
每一个 TypedArray
TypedArray.BYTES_PER_ELEMENT 的值是
该属性的特性为 { [[Writable]]:
TypedArray.prototype 的初始值是对应的 TypedArray 原型内置对象(
该属性的特性为 { [[Writable]]:
每个 TypedArray 原型对象:
TypedArray.prototype.BYTES_PER_ELEMENT 的值是
该属性的特性为 { [[Writable]]:
给定 TypedArray 的原型的
TypedArray 实例是
Map 是键/值对的集合,其中键和值都可以是任意的
Map 必须使用哈希表或其他机制来实现,这些机制平均提供对集合中元素数量的次线性访问时间。本规范中使用的数据结构仅用于描述 Map 的所需可观察语义,不打算作为可行的实现模型。
Map
extends 子句中用作值。打算继承指定 Map 行为的子类 super 调用,以便使用内部状态创建和初始化子类实例,以支持 Map.prototype 内置方法。调用此函数时执行以下步骤:
如果参数 iterable 存在,则期望它是一个实现了
抽象操作 AddEntriesFromIterable 接受参数 target(一个对象)、iterable(一个
参数 iterable 期望是一个实现了
Map 构造函数:
callbackfn 应为一个接受两个参数的函数。 groupBy 会按升序为 items 中的每个元素调用
callbackfn 一次,并构建一个新的 Map。 callbackfn 返回的每个值都作为 Map 的键。 对于每个这样的键,结果 Map
包含一个条目,其键为该键,值为一个包含所有 callbackfn 返回该键的元素的数组。
callbackfn 将使用两个参数调用:元素的值和元素的索引。
groupBy 的返回值是一个 Map。
调用此函数时执行以下步骤:
Map.prototype 的初始值是
此属性具有属性 { [[Writable]]:
Map[@@species] 是一个
此函数的
创建派生集合对象的方法应调用
Map 原型对象:
调用该方法时执行以下步骤:
Map.prototype.constructor 的初始值为
调用该方法时执行以下步骤:
使用
调用该方法时执行以下步骤:
调用该方法时执行以下步骤:
callbackfn 应该是一个接受三个参数的函数。对于 Map 中的每个键/值对,forEach 都会调用 callbackfn
一次,按照键插入的顺序。只有实际存在的 Map 键才会调用 callbackfn;已从 Map 中删除的键不会调用。
如果提供了 thisArg 参数,则它将作为每次调用 callbackfn 的
callbackfn 被调用时有三个参数:条目的值、条目的键和正在遍历的 Map。
forEach 不会直接改变其被调用的对象,但对象可能会被 callbackfn 的调用而改变。Map 的每个条目的 [[MapData]] 只会被访问一次。在调用 forEach 开始后添加的新键会被访问。如果在访问之后删除了键,并且在
forEach 调用完成之前重新添加了该键,则该键将被重新访问。在调用 forEach 开始后删除的键,在被访问之前重新添加之前,不会被访问。
调用该方法时执行以下步骤:
调用该方法时执行以下步骤:
调用该方法时执行以下步骤:
调用该方法时执行以下步骤:
Map.prototype.size 是一个
调用该方法时执行以下步骤:
该属性的特性为 { [[Writable]]:
Map 实例是
Map 迭代器是一个对象,表示对某个特定 Map 实例对象的特定迭代。Map 迭代器对象没有命名的
抽象操作 CreateMapIterator 接受参数 map(一个
%MapIteratorPrototype% 对象:
该属性具有属性 { [[Writable]]:
Set 对象是
Set 对象必须使用哈希表或其他机制实现,这些机制在平均情况下提供的访问时间应该是对集合中元素数量的次线性。此规范中使用的数据结构仅用于描述 Set 对象所需的可观察语义。它不应作为可行的实现模型。
Set
extends 子句的值。旨在继承指定 Set 行为的子类 super 调用,以创建和初始化子类实例,并具备支持 Set.prototype 内置方法所需的内部状态。此函数在调用时执行以下步骤:
Set
Set.prototype 的初始值为
该属性的特性为 { [[Writable]]:
Set[@@species] 是一个
该函数的
Set 原型对象:
调用此方法时执行以下步骤:
调用此方法时执行以下步骤:
Set.prototype.constructor 的初始值是
调用此方法时执行以下步骤:
值
调用此方法时执行以下步骤:
在迭代过程中,Set 的表现类似于 Map,其中每个条目的键和值相同。
调用此方法时执行以下步骤:
callbackfn 应该是一个接受三个参数的函数。forEach 会对 Set 对象中每个值调用一次
callbackfn,以值的插入顺序。callbackfn 仅对 Set 中实际存在的值进行调用;对已从 Set 中删除的键不会调用。
如果提供了 thisArg 参数,它将被用作每次调用 callbackfn 的
callbackfn 会接收三个参数:前两个参数是 Set 中的一个值。两个参数传递的是相同的值。遍历中的 Set 对象作为第三个参数传递。
callbackfn 使用三个参数是为了与 Map 和 Array 的 forEach 方法中的回调函数保持一致。对于 Sets,每个项值被认为是键和值。
forEach 不直接改变其调用的对象,但该对象可能会通过调用 callbackfn 发生变化。
每个值通常只访问一次。然而,如果一个值在被访问后被删除,然后在 forEach 调用完成前重新添加,则该值会被重新访问。在 forEach
开始后删除的值不会被访问,除非在 forEach 调用完成前再次添加。 forEach 开始后添加的新值会被访问。
调用此方法时执行以下步骤:
在迭代时,Set 看起来类似于 Map,其中每个条目的键和值相同。
Set.prototype.size 是一个
此方法在调用时执行以下步骤:
此属性具有 { [[Writable]]:
Set 实例是从 Set 原型继承属性的
Set 迭代器是一个
抽象操作 CreateSetIterator 接受参数 set(一个
%SetIteratorPrototype% 对象:
该属性具有以下特性:{ [[Writable]]:
WeakMap 是键/值对的集合,其中键是对象和/或符号,而值可以是任意的
实现可能在 WeakMap 的键/值对变得不可访问和从 WeakMap 中移除之间施加任意确定的延迟。如果这种延迟对 ECMAScript 程序可观察到,它将成为影响程序执行的不确定性来源。因此,ECMAScript 实现不得提供任何观察 WeakMap 键的手段,除非观察者能够提供观察到的键。
WeakMap 必须使用哈希表或其他机制实现,这些机制在平均情况下提供比集合中键/值对的数量更少的访问时间。本规范中使用的数据结构仅用于描述 WeakMap 的可观察语义。它并不是一个可行的实现模型。
WeakMap 和 WeakSet 旨在提供一种动态关联对象或符号状态的机制,这种机制不会“泄漏”内存资源,如果在没有 WeakMap 或 WeakSet 实例的情况下,对象或符号会变得不可访问并由实现的垃圾回收机制回收资源。可以通过使用 WeakMap 或 WeakSet 实例到键的反向每对象/符号映射来实现这一特性。或者,每个 WeakMap 或 WeakSet 实例可以内部存储其键和值数据,但这种方法需要 WeakMap 或 WeakSet 实现与垃圾回收器之间的协调。以下参考文献描述了可能对 WeakMap 和 WeakSet 实现有用的机制:
Barry Hayes. 1997. Ephemerons: a new finalization mechanism. 在 Proceedings of the 12th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications (OOPSLA '97) 中,A. Michael Berman(编辑)。ACM, New York, NY, USA, 176-183,http://doi.acm.org/10.1145/263698.263733。
Alexandra Barros, Roberto Ierusalimschy, Eliminating Cycles in Weak Tables. 《Journal of Universal Computer Science - J.UCS》,第 14 卷,第 21 期,第 3481-3497 页,2008 年,http://www.jucs.org/jucs_14_21/eliminating_cycles_in_weak
WeakMap
extends 子句中用作值。意图继承指定 WeakMap 行为的子类 super
调用,以创建并初始化子类实例,并具有支持 WeakMap.prototype 内置方法所需的内部状态。
当调用此函数时,执行以下步骤:
如果参数 iterable 存在,它应该是一个实现了
WeakMap
WeakMap.prototype 的初始值是
该属性具有属性 { [[Writable]]:
WeakMap 原型对象:
WeakMap.prototype.constructor 的初始值是
此方法在调用时执行以下步骤:
值
此方法在调用时执行以下步骤:
此方法在调用时执行以下步骤:
此方法在调用时执行以下步骤:
此属性具有 { [[Writable]]:
WeakMap 实例是
WeakSets 是对象和/或符号的集合。一个独特的对象或符号在 WeakSet 的集合中只能出现一次。可以查询 WeakSet 以查看是否包含特定值,但没有机制提供列举其包含的值。在某些条件下,不再
实现可能在值变得不可访问和从 WeakSet 中移除之间施加任意确定的延迟。如果这种延迟对 ECMAScript 程序可见,它将成为影响程序执行的不确定因素。因此,ECMAScript 实现不得提供任何手段来确定 WeakSet 是否包含某个特定值,且不要求观察者提供观察到的值。
WeakSets 必须使用哈希表或其他机制来实现,这些机制在平均情况下提供比集合中元素数量更低的访问时间。本规范中使用的数据结构仅用于描述 WeakSets 的可观察语义,并不是可行的实现模型。
参见
WeakSet
extends 子句中的值。意图继承指定 WeakSet 行为的子类 super
调用,以使用支持 WeakSet.prototype 内建方法所需的内部状态来创建并初始化子类实例。当调用此函数时,执行以下步骤:
WeakSet
WeakSet.prototype 的初始值是
该属性的特性为 { [[Writable]]:
WeakSet 原型对象:
此方法在调用时执行以下步骤:
WeakSet.prototype.constructor 的初始值是
此方法在调用时执行以下步骤:
值
此方法在调用时执行以下步骤:
该属性的特性为 { [[Writable]]:
WeakSet 实例是继承自 WeakSet 原型的
本节、
一个 读-修改-写修改函数
是一个数学函数,其表示为一个抽象闭包,接受两个
一个 固定长度的 ArrayBuffer 是一个在创建后其字节长度不能改变的 ArrayBuffer。
一个 可调整大小的 ArrayBuffer 是一个在创建后可以通过调用
创建的 ArrayBuffer 对象的类型取决于传递给
抽象操作 AllocateArrayBuffer 接受参数 constructor(一个
抽象操作 ArrayBufferByteLength 接受参数 arrayBuffer(一个 ArrayBuffer 或
SharedArrayBuffer)和 order(
抽象操作 ArrayBufferCopyAndDetach 接受参数 arrayBuffer(一个
realloc。抽象操作 IsDetachedBuffer 接受参数 arrayBuffer(一个 ArrayBuffer 或 SharedArrayBuffer),并返回一个布尔值。调用时执行以下步骤:
抽象操作 DetachArrayBuffer 接受参数 arrayBuffer(一个 ArrayBuffer)和可选参数 key(任意值),并返回一个
分离一个 ArrayBuffer 实例会将用作其后备存储的
抽象操作 CloneArrayBuffer 接受参数 srcBuffer(一个 ArrayBuffer 或
SharedArrayBuffer),srcByteOffset(一个非负
抽象操作 GetArrayBufferMaxByteLengthOption 接受参数 options(一个
主机定义的抽象操作 HostResizeArrayBuffer 接受参数 buffer(一个 ArrayBuffer)和 newByteLength
(一个非负的
HostResizeArrayBuffer 的实现必须符合以下要求:
HostResizeArrayBuffer 的默认实现是返回
抽象操作 IsFixedLengthArrayBuffer 接受参数 arrayBuffer(一个 ArrayBuffer 或 一个 SharedArrayBuffer)并返回一个布尔值。调用时执行以下步骤:
抽象操作 IsUnsignedElementType 接受参数 type(一个
抽象操作 IsUnclampedIntegerElementType 接受参数 type(一个
抽象操作 IsBigIntElementType 接受参数 type(一个
抽象操作 IsNoTearConfiguration 接受参数 type(一个
抽象操作 RawBytesToNumeric 接受参数 type(一个
抽象操作 GetRawBytesFromSharedBlock 接受参数 block(一个
抽象操作 GetValueFromBuffer 接受参数 arrayBuffer(一个 ArrayBuffer 或
SharedArrayBuffer),byteIndex(一个非负
抽象操作 NumericToRawBytes 接受参数 type(一个
抽象操作 SetValueInBuffer 接受参数 arrayBuffer(一个 ArrayBuffer 或 SharedArrayBuffer),
byteIndex(一个非负的
抽象操作 GetModifySetValueInBuffer 接受参数 arrayBuffer(一个 ArrayBuffer 或 SharedArrayBuffer),
byteIndex(一个非负的
ArrayBuffer
extends 子句的值。旨在继承指定 ArrayBuffer 行为的子类 super
调用,以创建和初始化子类实例,具备支持 ArrayBuffer.prototype 内置方法的内部状态。
调用此函数时,执行以下步骤:
ArrayBuffer
此函数在调用时执行以下步骤:
ArrayBuffer.prototype 的初始值是
该属性具有以下特性 { [[Writable]]:
ArrayBuffer[@@species] 是一个
此函数的
ArrayBuffer 原型对象:
ArrayBuffer.prototype.byteLength 是一个
ArrayBuffer.prototype.constructor 的初始值是
ArrayBuffer.prototype.detached 是一个
ArrayBuffer.prototype.maxByteLength 是一个
ArrayBuffer.prototype.resizable 是一个
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该属性的属性有 { [[Writable]]:
ArrayBuffer 实例继承自
当 ArrayBuffer 实例的 [[ArrayBufferData]] 为
当 ArrayBuffer 实例的 [[ArrayBufferDetachKey]] 被设置为除
以下是针对 ECMAScript 程序员在使用
我们建议在可能的情况下,在部署环境中对程序进行测试。不同硬件设备之间可用的物理内存差异很大。同样,虚拟内存子系统在硬件设备以及操作系统之间也有很大差异。一个在 64 位桌面浏览器上运行而没有内存不足错误的应用程序,在 32 位移动浏览器上可能会耗尽内存。
在为
请注意,成功构造一个具有特定最大大小的
以下是针对 ECMAScript 实现者在实现
如果一个
如果一个
固定长度的 SharedArrayBuffer 是一种其字节长度在创建后不能改变的 SharedArrayBuffer。
可增长的 SharedArrayBuffer 是一种其字节长度在创建后可以通过调用
创建的 SharedArrayBuffer 对象的类型取决于传递给
抽象操作 AllocateSharedArrayBuffer 接受参数 constructor(一个
抽象操作 IsSharedArrayBuffer 接受参数 obj(一个 ArrayBuffer 或 SharedArrayBuffer),并返回一个布尔值。它测试一个对象是否是 ArrayBuffer、SharedArrayBuffer 或它们的子类型。当调用时执行以下步骤:
共享数组缓冲区的原型对象:
SharedArrayBuffer
extends 子句的值。意图继承 SharedArrayBuffer 行为的子类 super
调用,以创建和初始化子类实例,并具有支持 SharedArrayBuffer.prototype 内置方法所需的内部状态。每当一个
与 ArrayBuffer 不同,SharedArrayBuffer 不能变为脱离状态,其内部 [[ArrayBufferData]] 插槽从不会是
当调用此函数时,它执行以下步骤:
SharedArrayBuffer
SharedArrayBuffer.prototype 的初始值是
此属性具有以下属性:{ [[Writable]]:
SharedArrayBuffer[@@species] 是一个
此函数的
SharedArrayBuffer 原型对象:
SharedArrayBuffer.prototype.byteLength 是一个
SharedArrayBuffer.prototype.constructor 的初始值是
此方法在调用时执行以下步骤:
禁止比较交换更新长度的虚假失败。如果新长度的边界检查通过且实现没有内存不足,则总是将
对 SharedArrayBuffer.prototype.grow 的并行调用是完全有序的。例如,考虑两个竞争调用:sab.grow(10) 和
sab.grow(20)。两个调用中的一个保证会赢得竞争。调用 sab.grow(10) 将永远不会缩小 sab,即使
sab.grow(20) 先发生;在这种情况下,它将抛出一个 RangeError。
SharedArrayBuffer.prototype.growable 是一个
SharedArrayBuffer.prototype.maxByteLength 是一个
此方法在调用时执行以下步骤:
此属性具有以下特性 { [[Writable]]:
SharedArrayBuffer 实例继承自
与 ArrayBuffer 实例不同,SharedArrayBuffer 实例从不分离。
以下是为 ECMAScript 程序员在使用
我们建议程序在可能的部署环境中进行测试。不同硬件设备之间的可用物理内存量差异很大。同样,不同硬件设备和操作系统之间的虚拟内存子系统也有很大差异。在 64 位桌面浏览器上运行无内存不足错误的应用程序可能会在 32 位移动浏览器上运行时内存不足。
在为
请注意,成功构建具有特定最大大小的
并非所有对 u8[idx],不是同步的。通常,在没有显式同步的情况下,一个属性访问在边界内并不意味着同一 length 和 byteLength
获取器显式加载的长度是同步的。内建方法执行的检查
以下是为实现
我们建议
因为增长操作可以与
增长的内存必须从创建时起就显示为零,包括任何并行的竞争访问。这可以通过按需零填充的虚拟内存页面来实现,或者如果手动清零内存,则需要小心同步。
在
实际上,在没有虚拟内存的
具有缓冲区见证记录的 DataView 是一个
具有缓冲区见证记录的 DataView 包含
| 字段名称 | 值 | 含义 |
|---|---|---|
| [[Object]] | 一个 DataView | 其缓冲区的字节长度被加载的 DataView 对象。 |
| [[CachedBufferByteLength]] | 一个非负 |
创建 |
抽象操作 MakeDataViewWithBufferWitnessRecord 接受参数 obj(一个 DataView)和
order(
抽象操作 GetViewByteLength 接受参数 viewRecord(一个
抽象操作 IsViewOutOfBounds 接受参数 viewRecord(一个
抽象操作 GetViewValue 接受参数 view(一个
抽象操作 SetViewValue 接受参数 view(一个
DataView
extends 子句的值。继承指定 DataView 行为的子类 super 调用,以创建和初始化具有支持 DataView.prototype 内置方法的内部状态的子类实例。
此函数在调用时执行以下步骤:
DataView
DataView.prototype 的初始值是
该属性具有以下特性 { [[Writable]]:
DataView 原型对象:
DataView.prototype.buffer 是一个
DataView.prototype.byteLength 是一个
DataView.prototype.byteOffset 是一个
DataView.prototype.constructor 的初始值是
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
此属性具有 { [[Writable]]:
DataView 实例是
在本规范中不使用 [[DataView]] 内部槽位的值。该内部槽位的存在本身在规范中用于标识使用 DataView
Atomics 对象:
new 运算符作为Atomics 对象提供对共享内存数组单元进行不可分割(原子)操作的函数,以及让
有关在 ECMAScript 中编程和实现共享内存的信息指南,请参见
Waiter 记录是一个用于表示对 Atomics.wait 或
Atomics.waitAsync 的特定调用的
Waiter 记录具有
WaiterList 记录用于解释通过
Atomics.wait、Atomics.waitAsync 和 Atomics.notify 对
WaiterList 记录具有
在一个 WaiterList 中可以有多个具有相同
每个 WaiterList 记录都有一个控制在评估期间对该 WaiterList 记录的独占访问的临界区。一次只能有一个
抽象操作 ValidateIntegerTypedArray 接受参数 typedArray(一个
抽象操作 ValidateAtomicAccess 接受参数 taRecord(一个
抽象操作 ValidateAtomicAccessOnIntegerTypedArray 接受参数 typedArray
(一个
抽象操作 RevalidateAtomicAccess 接受参数 typedArray(一个
抽象操作 GetWaiterList 接受参数 block(一个
抽象操作 EnterCriticalSection 接受参数 WL(一个
当一个
抽象操作 LeaveCriticalSection 接受参数 WL(一个
抽象操作 AddWaiter 接受参数 WL(一个
抽象操作 RemoveWaiter 接受参数 WL(一个
抽象操作 RemoveWaiters 接受参数 WL(一个
抽象操作 SuspendThisAgent 接受参数 WL(一个
Atomics.notify)而从挂起中唤醒。
抽象操作 NotifyWaiter 接受参数 WL(一个
抽象操作 EnqueueResolveInAgentJob 接受参数 agentSignifier(一个
抽象操作 DoWait 接受参数 mode(
additionalTimeout 允许实现按需要填充超时,例如减少电量消耗或粗化计时器分辨率以缓解计时攻击。此值可能在每次调用 DoWait 时有所不同。
当调用时,抽象操作 EnqueueAtomicsWaitAsyncTimeoutJob 接受参数 WL(一个
当调用时,抽象操作 AtomicCompareExchangeInSharedBlock 接受参数 block(一个
抽象操作 AtomicReadModifyWrite 接受参数 typedArray(一个
抽象操作 ByteListBitwiseOp 接受参数 op(&、^ 或
|)、xBytes(一个
&,则
^,则
|。
抽象操作 ByteListEqual 接受参数 xBytes(一个
此函数在调用时执行以下步骤:
此函数在调用时执行以下步骤:
&,
xBytes, yBytes)。
此函数在调用时执行以下步骤:
此函数在调用时执行以下步骤:
此函数在调用时执行以下步骤:
此函数是一个优化原语。直观上,如果大小为 n
字节的数据的原子步骤(compareExchange、load、store、add、sub、and、or、xor
或 exchange)将不会使 Atomics.isLockFree(n) 将返回
Atomics.isLockFree(4) 总是返回
无论此函数返回的值如何,所有原子操作都保证是原子的。例如,它们永远不会在操作中途出现可见的操作(例如,“撕裂”)。
此函数在调用时执行以下步骤:
此函数在调用时执行以下步骤:
|,
xBytes, yBytes)。
此函数在调用时执行以下步骤:
此函数在调用时执行以下步骤:
此函数将
它在调用时执行以下步骤:
此函数返回一个 Promise,当调用的
它在调用时执行以下步骤:
此函数通知在等待队列中睡眠的一些
它在调用时执行以下步骤:
此函数在调用时执行以下步骤:
^,
xBytes, yBytes)。
@@toStringTag 属性的初始值是字符串值
此属性具有以下属性:{ [[Writable]]:
JSON 对象:
parse 和 stringify,用于解析和构建 JSON 文本。new 运算符一起用作 JSON 数据交换格式在 ECMA-404 中定义。本规范中使用的 JSON 交换格式与 ECMA-404 所描述的完全一致。JSON.parse 和
JSON.stringify 的符合实现必须支持 ECMA-404 规范中描述的准确交换格式,不得对格式进行任何删减或扩展。
该函数解析 JSON 文本(JSON 格式的字符串)并生成一个
可选的 reviver 参数是一个函数,接受两个参数 key 和 value。它可以过滤和转换结果。它被解析生成的每个
key/value 对调用,其返回值用于替换原始值。如果它返回接收到的值,则结构不变。如果返回
该函数的
抽象操作 InternalizeJSONProperty 接受参数 holder(对象),name(字符串),和
reviver(
如果 [[Delete]] 或
当调用时,它执行以下步骤:
对于符合标准的 JSON.parse 实现,不允许扩展 JSON 语法。如果某个实现希望支持修改或扩展的 JSON 交换格式,必须通过定义不同的解析函数来实现。
如果对象中存在重复的名称字符串,词法上前面的值将被覆盖。
该函数返回一个 UTF-16 编码的 JSON 格式字符串,表示一个
调用时,它执行以下步骤:
该函数的
JSON 结构允许嵌套到任意深度,但必须是非循环的。如果 value 是或包含循环结构,则该函数必须抛出
a = [];
a[0] = a;
my_text = JSON.stringify(a); // This must throw a TypeError.
符号原始值按如下方式呈现:
字符串值用引号 (") 代码单元括起来。代码单元 " 和 \ 用 \
前缀进行转义。控制字符代码单元替换为转义序列 \uHHHH,或更短形式,如
\b(退格)、\f(换页)、\n(换行)、\r(回车)、\t(制表符)。
没有 JSON 表示的值(如
对象呈现为 U+007B(左大括号)后跟零个或多个属性,用 U+002C(逗号)分隔,以 U+007D(右大括号)结尾。属性是表示
一个 JSON 序列化记录 是一个
JSON 序列化记录具有在
| 字段名 | 值 | 含义 |
|---|---|---|
| [[ReplacerFunction]] | 一个 |
一个可以为对象属性提供替代值的函数(来自 JSON.stringify 的 replacer 参数)。 |
| [[PropertyList]] | 一个 |
在序列化非数组对象时包含的属性名称(来自 JSON.stringify 的 replacer 参数)。 |
| [[Gap]] | 一个字符串 | 缩进单位(来自 JSON.stringify 的 space 参数)。 |
| [[Stack]] | 一个 |
正在被序列化的嵌套对象集。用于检测循环结构。 |
| [[Indent]] | 一个字符串 | 当前的缩进。 |
抽象操作 SerializeJSONProperty 接受参数 state(一个
抽象操作 QuoteJSONString 接受一个参数 value(一个字符串),并返回一个字符串。它将 value 包裹在
0x0022(引号)代码单元中,并对其中的某些其他代码单元进行转义。该操作将 value 解释为 UTF-16 编码的代码点序列,如
| 代码点 | Unicode 字符名称 | 转义序列 |
|---|---|---|
| U+0008 | 退格 |
\b
|
| U+0009 | 制表符 |
\t
|
| U+000A | 换行 (LF) |
\n
|
| U+000C | 换页 (FF) |
\f
|
| U+000D | 回车 (CR) |
\r
|
| U+0022 | 引号 |
\"
|
| U+005C | 反斜杠 |
\\
|
抽象操作 UnicodeEscape 接受一个参数 C(一个代码单元),并返回一个字符串。它将 C 表示为一个 Unicode 转义序列。它在调用时执行以下步骤:
抽象操作 SerializeJSONObject 接受两个参数 state(一个
抽象操作 SerializeJSONArray 接受两个参数 state(一个
该属性的特性为 { [[Writable]]:
A
WeakRef
extends 子句的值。旨在继承指定的 WeakRef 行为的子类 super 调用到 WeakRef WeakRef.prototype 内置方法。
此函数在调用时执行以下步骤:
WeakRef.prototype 的初始值是
该属性的属性描述符为 { [[Writable]]:
WeakRef 原型 对象:
WeakRef.prototype.constructor 的初始值是
该属性的属性描述符为 { [[Writable]]:
调用此方法时执行以下步骤:
如果
let target = { foo() {} };
let weakRef = new WeakRef(target);
// ... later ...
if (weakRef.deref()) {
weakRef.deref().foo();
}
在上面的示例中,如果第一次 deref 不返回
此属性具有以下特性 { [[Writable]]:
抽象操作 WeakRefDeref 接受参数 weakRef(一个
此抽象操作与 WeakRef.prototype.deref 的定义是分开的,主要是为了便于简洁地定义存活性。
FinalizationRegistry
extends 子句中的值。旨在继承指定 FinalizationRegistry 行为的子类 super 调用到 FinalizationRegistry FinalizationRegistry.prototype 内置方法所需的内部状态。
当调用此函数时,执行以下步骤:
FinalizationRegistry.prototype 的初始值为
该属性具有以下特性:{ [[Writable]]:
FinalizationRegistry 原型 对象:
FinalizationRegistry.prototype.constructor 的初始值是
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
该属性具有以下特性:{ [[Writable]]:
接口是一组
Iterable 接口包括在
| 属性 | 值 | 要求 |
|---|---|---|
@@iterator
|
返回一个 Iterator 对象的函数 | 返回的对象必须符合 Iterator 接口。 |
实现了 Iterator 接口的对象必须包含在
| 属性 | 值 | 要求 |
|---|---|---|
|
|
返回一个 IteratorResult 对象的函数 |
返回的对象必须符合 IteratorResult 接口。如果对 Iterator 的 next 方法的先前调用返回了一个其
next 方法调用也应该返回一个其 |
可以将参数传递给 next 函数,但它们的解释和有效性取决于目标 Iterator。for-of 语句和其他常见的
Iterator 用户不会传递任何参数,因此预期用于这种方式的 Iterator 对象必须能够处理无参数调用。
| 属性 | 值 | 要求 |
|---|---|---|
|
|
返回一个 IteratorResult 对象的函数 |
返回的对象必须符合 IteratorResult 接口。调用此方法会通知 Iterator 对象调用者不打算再对 Iterator 进行更多的
next 方法调用。返回的 IteratorResult 对象通常会有一个 return
方法的参数。然而,这一要求并不强制执行。
|
|
|
返回一个 IteratorResult 对象的函数 |
返回的对象必须符合 IteratorResult 接口。调用此方法会通知 Iterator
对象调用者检测到了一个错误条件。参数可以用于识别错误条件,通常是一个异常对象。典型的响应是 throw 传递的参数值。如果方法不
throw,返回的 IteratorResult 对象通常会有一个 |
通常,调用这些方法的调用者应在调用之前检查其存在性。包括 for-of、yield* 和数组解构在内的某些
ECMAScript 语言特性会在执行存在性检查后调用这些方法。大多数接受 Iterable 对象作为参数的 ECMAScript 库函数也会有条件地调用这些方法。
AsyncIterable 接口包括在
| 属性 | 值 | 要求 |
|---|---|---|
@@asyncIterator |
返回一个 AsyncIterator 对象的函数 | 返回的对象必须符合 AsyncIterator 接口。 |
实现 AsyncIterator 接口的对象必须包括
| 属性 | 值 | 要求 |
|---|---|---|
| 返回一个 IteratorResult 对象的 promise |
返回的 promise 被兑现时,必须兑现为一个符合 IteratorResult 接口的对象。如果对一个
AsyncIterator 的 此外,作为兑现值的 IteratorResult 对象应具有一个 |
可以将参数传递给 next 函数,但其解释和有效性取决于目标 AsyncIterator。
for-await-of 语句和其他常见的 AsyncIterators 使用者不传递任何
参数,因此期望以这种方式使用的 AsyncIterator 对象必须能够处理无参数调用。
| 属性 | 值 | 要求 |
|---|---|---|
| 返回一个 IteratorResult 对象的 promise |
返回的 promise 被兑现时,必须兑现为一个符合 IteratorResult 接口的对象。调用此方法
通知 AsyncIterator 对象调用者不打算再对该 AsyncIterator 进行更多的 此外,作为兑现值的 IteratorResult 对象应具有一个 |
|
| 返回一个 IteratorResult 对象的 promise |
返回的 promise 被兑现时,必须兑现为一个符合 IteratorResult 接口的对象。调用此方法 通知 AsyncIterator 对象调用者已经检测到错误条件。参数可以用于标识错误条件,通常将是 一个异常对象。典型的响应是返回一个被拒绝的 promise,该 promise 被拒绝的原因是传递的参数。 如果返回的 promise 被兑现,IteratorResult 的兑现值通常具有一个 |
通常,调用这些方法的调用者应该在调用之前检查它们的存在。某些 ECMAScript 语言特性,包括
for-await-of 和 yield*,在进行存在性检查后调用
这些方法。
IteratorResult 接口包括
| 属性 | 值 | 要求 |
|---|---|---|
| 布尔值 | 这是 iterator next 方法调用的结果状态。如果迭代器已到达末尾, |
|
| 一个 |
如果 |
%IteratorPrototype% 对象:
本规范中所有实现 Iterator 接口的对象也都继承自 %IteratorPrototype%。 ECMAScript 代码也可以定义继承自 %IteratorPrototype% 的对象。%IteratorPrototype% 对象提供了一个可以为所有迭代器对象添加额外方法的地方。
以下表达式是 ECMAScript 代码访问 %IteratorPrototype% 对象的一种方式:
Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()))
调用此函数时执行以下步骤:
此函数的
%AsyncIteratorPrototype% 对象:
本规范中所有实现 AsyncIterator 接口的对象也都继承自 %AsyncIteratorPrototype%。 ECMAScript 代码也可以定义继承自 %AsyncIteratorPrototype% 的对象。%AsyncIteratorPrototype% 对象提供了一个可以为所有异步迭代器对象添加额外方法的地方。
调用此函数时执行以下步骤:
此函数的
异步从同步迭代器对象是一个异步迭代器,它适配一个特定的同步迭代器。异步从同步迭代器对象没有命名的
抽象操作 CreateAsyncFromSyncIterator 接受参数 syncIteratorRecord (一个
%AsyncFromSyncIteratorPrototype% 对象:
异步-从同步迭代器实例是
| 内部插槽 | 类型 | 描述 |
|---|---|---|
| [[SyncIteratorRecord]] |
一个 |
表示正在被适配的原始同步迭代器。 |
抽象操作 AsyncFromSyncIteratorContinuation 接受两个参数 result(一个对象)和 promiseCapability(一个
Promise 是一个对象,用作延迟(可能是异步)计算的最终结果的占位符。
任何 Promise 都处于三种互斥状态之一:已兑现、已拒绝 和 待定:
p.then(f, r) 会立即排队一个 f,那么 Promise p
就是已兑现的。
p.then(f, r) 会立即排队一个 r,那么 Promise p
就是已拒绝的。
如果一个 Promise 不是待定的,即它是已兑现的或已拒绝的,那么它被称为 已解决。
如果一个 Promise 是已解决的,或者它已经被“锁定”以匹配另一个 Promise 的状态,那么它是 已解决 的。尝试解决或拒绝一个已解决的 Promise 是没有效果的。如果一个 Promise 没有被解决,则它是 未解决 的。未解决的 Promise 始终处于待定状态。已解决的 Promise 可能是待定的、已兑现的或已拒绝的。
PromiseCapability 记录 是一种
PromiseCapability 记录包含在
| 字段名称 | 值 | 含义 |
|---|---|---|
| [[Promise]] | 一个对象 | 一个可用作 Promise 的对象。 |
| [[Resolve]] |
一个 |
用于解析给定 Promise 的函数。 |
| [[Reject]] |
一个 |
用于拒绝给定 Promise 的函数。 |
IfAbruptRejectPromise 是对使用
意味着与以下内容相同:
PromiseReaction 记录 是一种
PromiseReaction 记录具有在
| 字段名称 | 值 | 含义 |
|---|---|---|
| [[Capability]] |
一个 |
提供反应处理程序的 Promise 的能力。 |
| [[Type]] |
|
[[Type]] 用于当 [[Handler]] 为
|
| [[Handler]] |
一个 |
应应用于传入值的函数,其返回值将决定派生 Promise 的处理方式。如果 [[Handler]] 为
|
抽象操作 CreateResolvingFunctions 接受参数 promise(一个 Promise)并返回一个
Promise 拒绝函数是一个匿名内置函数,具有 [[Promise]] 和 [[AlreadyResolved]] 内部槽位。
当 Promise 拒绝函数以参数 reason 调用时,执行以下步骤:
Promise 拒绝函数的
Promise 解析函数是一个匿名内置函数,具有 [[Promise]] 和 [[AlreadyResolved]] 内部槽位。
当 Promise 解析函数以参数 resolution 调用时,执行以下步骤:
Promise 解析函数的
抽象操作 FulfillPromise 接受参数 promise(一个 Promise)和 value(一个
抽象操作 NewPromiseCapability 接受参数 C(一个 resolve 和 reject 函数。这个 promise 以及 resolve 和 reject
函数将用于初始化一个新的
抽象操作 IsPromise 接受参数 x(一个
抽象操作 RejectPromise 接受参数 promise(一个 Promise)和 reason(一个
抽象操作 TriggerPromiseReactions 接受参数 reactions(一个
HostPromiseRejectionTracker 的默认实现是返回
HostPromiseRejectionTracker 在以下两种情况下被调用:
HostPromiseRejectionTracker 的典型实现可能会尝试通知开发人员未处理的拒绝,同时也要注意在新处理程序被附加时通知开发人员如果之前的通知被无效化。
如果 operation 是
抽象操作 NewPromiseReactionJob 接受两个参数 reaction(一个
抽象操作 NewPromiseResolveThenableJob 接受三个参数 promiseToResolve(一个
Promise),thenable(一个对象)和 then(一个
Promise
extends 子句中的值。继承指定 Promise 行为的子类 super 调用,以使用支持 Promise 和 Promise.prototype
内置方法所需的内部状态来创建和初始化子类实例。该函数在调用时执行以下步骤:
executor 参数必须是
传递给 executor 函数的 resolve 函数接受一个参数。 executor 代码可能最终调用 resolve 函数以指示希望解析关联的 Promise。 传递给 resolve 函数的参数代表延迟操作的最终值,可以是实际的履行值,也可以是另一个 Promise,该 Promise 将在履行时提供该值。
传递给 executor 函数的 reject 函数接受一个参数。 executor 代码可能最终调用 reject 函数以指示关联的 Promise 被拒绝且永远不会被履行。 传递给 reject 函数的参数用作 Promise 的拒绝值。 通常,它将是一个 Error 对象。
传递给 executor 函数的 resolve 和 reject 函数具有实际解析和拒绝关联 Promise 的能力。 子类可能有不同的
Promise
此函数返回一个新的 promise,该 promise 会被一个包含传入的 promises 的 fulfillment 值的数组所兑现,或者被第一个拒绝的传入 promise 的原因所拒绝。它在运行此算法时会将传入的 iterable 中的所有元素解析为 promises。
抽象操作 GetPromiseResolve 接受参数 promiseConstructor(一个
抽象操作 PerformPromiseAll 接受参数 iteratorRecord、promiseConstructor、promiseCapability 和 promiseResolve。它会处理 iteratorRecord 中的每个项,并在完成时解决 promiseCapability。如果在处理时遇到拒绝,promiseCapability 会被拒绝。
抽象操作 ResolvePromiseAll 接受参数 values 和 promiseCapability。它会将 values 作为一个 promise 的集合来处理,当所有这些 promises 完成时,promiseCapability 将被解决;如果有任何 promise 被拒绝,则 promiseCapability 会被拒绝。
此函数返回一个 promise,该 promise 会被一个包含所有传入 promise 状态快照的数组兑现,但只有在所有原始 promise 都已完成(即已兑现或拒绝)之后。它在运行此算法时会将传入的 iterable 中的所有元素解析为 promises。
抽象操作 PerformPromiseAllSettled 接受参数 iteratorRecord(一个
Promise.allSettled
解决元素函数Promise.allSettled
解决元素函数Promise.allSettled
拒绝元素函数Promise.allSettled
拒绝元素函数Promise.allSettled 解决元素函数Promise.allSettled 解决元素函数是一个匿名内置函数,用于解决特定的 Promise.allSettled 元素。每个
Promise.allSettled 解决元素函数都有 [[Index]]、[[Values]]、[[Capability]]、[[RemainingElements]] 和 [[AlreadyCalled]] 内部槽。
当调用 Promise.allSettled 解决元素函数并带有参数 x 时,执行以下步骤:
一个 Promise.allSettled 解决元素函数的
Promise.allSettled 拒绝
元素函数Promise.allSettled 拒绝元素函数是一个匿名内置函数,用于拒绝特定的 Promise.allSettled 元素。每个
Promise.allSettled 拒绝元素函数都有 [[Index]]、[[Values]]、[[Capability]]、[[RemainingElements]] 和 [[AlreadyCalled]] 内部槽。
当调用 Promise.allSettled 拒绝元素函数并带有参数 x 时,执行以下步骤:
一个 Promise.allSettled 拒绝元素函数的
此函数返回一个承诺,该承诺由第一个完成的承诺实现,或者如果所有给定的承诺都被拒绝,则由一个持有拒绝原因的 AggregateError
拒绝。它在执行此算法时将传递的可迭代对象的所有元素解析为承诺。
此函数要求其 Promise
抽象操作 PerformPromiseAny 接受以下参数:iteratorRecord(一个
Promise.any
拒绝元素函数Promise.any
拒绝元素函数Promise.any 拒绝元素函数Promise.any 拒绝元素函数是一个匿名内置函数,用于拒绝特定的 Promise.any 元素。每个
Promise.any 拒绝元素函数都有 [[Index]]、[[Errors]]、[[Capability]]、[[RemainingElements]] 和 [[AlreadyCalled]] 内部槽。
当调用 Promise.any 拒绝元素函数并传递参数 x 时,将执行以下步骤:
Promise.any 拒绝元素函数的
Promise.prototype 的初始值是
该属性具有属性 { [[Writable]]:
此函数返回一个新承诺,该承诺以与第一个完成的承诺相同的方式解决。它在执行此算法时会将传入的 iterable 中的所有元素解析为承诺。
如果 iterable 参数不生成任何值或如果 iterable 生成的承诺都未解决,那么此方法返回的待定承诺将永远不会解决。
此函数期望其 resolve 方法。
抽象操作 PerformPromiseRace 接受参数 iteratorRecord(一个
此函数返回一个新承诺,该承诺以传入的参数被拒绝。
此函数期望其
此函数返回一个新承诺,该承诺以传入的参数被解决,或者如果参数本身是由此
此函数期望其
抽象操作 PromiseResolve 接受参数 C(一个
此函数返回一个对象,该对象具有三个属性:一个新的承诺以及与之关联的 resolve 和 reject 函数。
Promise[@@species] 是一个
该函数的
Promise 原型对象:
该方法在调用时执行以下步骤:
Promise.prototype.constructor 的初始值为
该方法在调用时执行以下步骤:
该方法在调用时执行以下步骤:
抽象操作 PerformPromiseThen 接受参数 promise(一个 Promise)、onFulfilled(一个
该属性具有以下属性:{ [[Writable]]:
Promise 实例是
| 内部槽 | 类型 | 描述 |
|---|---|---|
| [[PromiseState]] |
|
决定 Promise 如何响应对其 then 方法的调用。
|
| [[PromiseResult]] |
一个 |
Promise 被履行或拒绝的值(如果有的话)。仅在 [[PromiseState]] 不是
|
| [[PromiseFulfillReactions]] |
一个 |
当 Promise 从 |
| [[PromiseRejectReactions]] |
一个 |
当 Promise 从 |
| [[PromiseIsHandled]] | 一个布尔值 | 表示 Promise 是否曾经有过履行或拒绝处理程序;用于未处理拒绝的追踪。 |
GeneratorFunctions 是通常通过评估
GeneratorFunction
Function 的子类。GeneratorFunction (…) 等同于对象创建表达式
new GeneratorFunction (…),并使用相同的参数。
extends 子句的值。意图继承指定的 GeneratorFunction 行为的子类 super
调用,以创建并初始化子类实例,并为内建的 GeneratorFunction 行为提供必要的内部槽。所有 ECMAScript 语法形式用于定义生成器 最后一个参数(如果有的话)指定生成器函数的主体(可执行代码);任何前面的参数指定正式参数。
此函数在调用时执行以下步骤:
参见
GeneratorFunction
GeneratorFunction.prototype的初始值是
该属性具有 { [[Writable]]:
GeneratorFunction 原型对象:
GeneratorFunction.prototype.constructor的初始值是
该属性具有 { [[Writable]]:
GeneratorFunction.prototype.prototype的初始值是
该属性具有 { [[Writable]]:
该属性具有 { [[Writable]]:
每个 GeneratorFunction 实例都是一个 ECMAScript
每个 GeneratorFunction 实例都有以下自有属性:
每当创建一个 GeneratorFunction 实例时,另一个
该属性具有 { [[Writable]]:
与 Function 实例不同,作为 GeneratorFunction 的
AsyncGeneratorFunctions 是通常通过计算
AsyncGeneratorFunction
Function的子类。AsyncGeneratorFunction (...)等同于对象创建表达式new AsyncGeneratorFunction (...),并带有相同的参数。
extends子句的值。意图继承指定 AsyncGeneratorFunction 行为的子类super调用,以使用内建
AsyncGeneratorFunction 行为所需的内部槽创建和初始化子类实例。所有 ECMAScript 定义异步生成器最后一个参数(如果有的话)指定异步生成器函数的主体(可执行代码);之前的任何参数指定形式参数。
此函数在调用时执行以下步骤:
参见
AsyncGeneratorFunction
AsyncGeneratorFunction.prototype的初始值是
该属性具有 { [[Writable]]:
AsyncGeneratorFunction 原型对象:
AsyncGeneratorFunction.prototype.constructor的初始值是
该属性具有 { [[Writable]]:
AsyncGeneratorFunction.prototype.prototype的初始值是
该属性具有 { [[Writable]]:
该属性具有 { [[Writable]]:
每个 AsyncGeneratorFunction 实例都是一个 ECMAScript
每个 AsyncGeneratorFunction 实例都有以下自有属性:
该属性具有 { [[Writable]]:
Function 实例的
每当创建一个 AsyncGeneratorFunction 实例时,另一个
该属性具有 { [[Writable]]:
与函数实例不同,作为 AsyncGeneratorFunction 的
Generator 是生成器函数的实例,并符合Iterator和Iterable接口。
Generator 实例直接从创建该实例的 Generator 函数的
Generator 原型对象:
Generator.prototype.constructor的初始值是
该属性具有 { [[Writable]]:
此方法在调用时执行以下步骤:
此方法在调用时执行以下步骤:
该属性具有 { [[Writable]]:
Generator 实例最初创建时具有
| 内部槽 | 类型 | 描述 |
|---|---|---|
| [[GeneratorState]] |
|
< td>
生成器的当前执行状态。
|
| [[GeneratorContext]] |
一个 |
执行此生成器代码时使用的 |
| [[GeneratorBrand]] |
一个字符串或 |
用于区分不同类型生成器的标记。 |
抽象操作 GeneratorStart 接受参数 generator(一个 Generator)和 generatorBody(一个
抽象操作 GeneratorValidate 接受参数 generator(一个
抽象操作 GeneratorResume 接受参数 generator(一个
抽象操作 GeneratorResumeAbrupt 接受参数 generator(一个
抽象操作 GetGeneratorKind
不接受参数,并返回
抽象操作 GeneratorYield 接受参数 iterNextObj(一个符合IteratorResult接口的对象),并返回
抽象操作 Yield 接受参数 value(一个
抽象操作 CreateIteratorFromClosure 接受参数 closure(一个没有参数的
An AsyncGenerator is an instance of an async generator function and conforms to both the AsyncIterator and AsyncIterable interfaces.
AsyncGenerator instances directly inherit properties from the object that is the initial value of the
The AsyncGenerator prototype object:
The initial value of AsyncGenerator.prototype.constructor is
This property has the attributes { [[Writable]]:
The initial value of the
This property has the attributes { [[Writable]]:
AsyncGenerator instances are initially created with the internal slots described below:
| Internal Slot | Type | Description |
|---|---|---|
| [[AsyncGeneratorState]] | The current execution state of the async generator. | |
| [[AsyncGeneratorContext]] | an |
The |
| [[AsyncGeneratorQueue]] | a |
|
| [[GeneratorBrand]] | a String or |
A brand used to distinguish different kinds of async generators. The [[GeneratorBrand]] of async generators declared by |
An AsyncGeneratorRequest is a
They have the following fields:
| Field Name | Value | Meaning |
|---|---|---|
| [[Completion]] | a |
The |
| [[Capability]] | a |
The promise capabilities associated with this request. |
The abstract operation AsyncGeneratorStart takes arguments generator (an AsyncGenerator)
and
generatorBody (a
The abstract operation AsyncGeneratorValidate takes arguments generator (an
The abstract operation AsyncGeneratorEnqueue takes arguments generator (an
AsyncGenerator),
completion (a
The abstract operation AsyncGeneratorCompleteStep takes arguments generator (an
AsyncGenerator), completion (a
The abstract operation AsyncGeneratorResume takes arguments generator (an AsyncGenerator)
and
completion (a
The abstract operation AsyncGeneratorUnwrapYieldResumption takes argument resumptionValue
(a
The abstract operation AsyncGeneratorYield takes argument value (an
The abstract operation AsyncGeneratorAwaitReturn takes argument generator (an
AsyncGenerator)
and returns either a
The abstract operation AsyncGeneratorDrainQueue takes argument generator (an
AsyncGenerator)
and returns
The abstract operation CreateAsyncIteratorFromClosure takes arguments closure (an
AsyncFunctions are functions that are usually created by evaluating
The AsyncFunction
Function.AsyncFunction(…) is equivalent to the object creation expression
new AsyncFunction(…) with the same arguments.
extends clause of a class definition. Subclass super call to the AsyncFunction
The last argument (if any) specifies the body (executable code) of an async function. Any preceding arguments specify formal parameters.
This function performs the following steps when called:
The AsyncFunction
The initial value of AsyncFunction.prototype is the
This property has the attributes { [[Writable]]:
The AsyncFunction prototype object:
The initial value of AsyncFunction.prototype.constructor is
This property has the attributes { [[Writable]]:
The initial value of the
This property has the attributes { [[Writable]]:
Every AsyncFunction instance is an ECMAScript
Each AsyncFunction instance has the following own properties:
The specification for the
The specification for the
The abstract operation AsyncFunctionStart takes arguments promiseCapability (a
The abstract operation AsyncBlockStart takes arguments promiseCapability (a
The abstract operation Await takes argument value (an
The Reflect object:
new
operator.
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
The initial value of the
This property has the attributes { [[Writable]]:
The Proxy
This function performs the following steps when called:
The Proxy
This function creates a revocable Proxy object.
It performs the following steps when called:
A Module Namespace Object is a
In addition to the properties specified in
The initial value of the
This property has the attributes { [[Writable]]:
The memory consistency model, or memory model, specifies the possible orderings of
The memory model is defined as relational constraints on events introduced by
This section provides an axiomatic model on events introduced by the
Shared memory accesses (reads and writes) are divided into two groups, atomic accesses and data accesses,
defined below. Atomic accesses are sequentially consistent, i.e., there is a strict total ordering of
events
agreed upon by all
No orderings weaker than sequentially consistent and stronger than unordered, such as release-acquire, are supported.
A Shared Data Block event is either a ReadSharedMemory, WriteSharedMemory, or ReadModifyWriteSharedMemory
| Field Name | Value | Meaning |
|---|---|---|
| [[Order]] | The weakest ordering guaranteed by the |
|
| [[NoTear]] | a Boolean | Whether this event is allowed to read from multiple write events with equal range as this event. |
| [[Block]] | a |
The block the event operates on. |
| [[ByteIndex]] | a non-negative |
The byte address of the read in [[Block]]. |
| [[ElementSize]] | a non-negative |
The size of the read. |
| Field Name | Value | Meaning |
|---|---|---|
| [[Order]] | The weakest ordering guaranteed by the |
|
| [[NoTear]] | a Boolean | Whether this event is allowed to be read from multiple read events with equal range as this event. |
| [[Block]] | a |
The block the event operates on. |
| [[ByteIndex]] | a non-negative |
The byte address of the write in [[Block]]. |
| [[ElementSize]] | a non-negative |
The size of the write. |
| [[Payload]] | a |
The |
| Field Name | Value | Meaning |
|---|---|---|
| [[Order]] | Read-modify-write events are always sequentially consistent. | |
| [[NoTear]] | Read-modify-write events cannot tear. | |
| [[Block]] | a |
The block the event operates on. |
| [[ByteIndex]] | a non-negative |
The byte address of the read-modify-write in [[Block]]. |
| [[ElementSize]] | a non-negative |
The size of the read-modify-write. |
| [[Payload]] | a |
The |
| [[ModifyOp]] | a |
An abstract closure that returns a modified |
These events are introduced by
Some operations may also introduce Synchronize events. A Synchronize event has no fields, and exists purely to directly constrain the permitted orderings of other events.
In addition to
Let the range of a ReadSharedMemory, WriteSharedMemory, or ReadModifyWriteSharedMemory event be the Set
of
contiguous
Examples of postMessage in a browser), starting and stopping
Events are ordered within
An Agent Events Record is a
| Field Name | Value | Meaning |
|---|---|---|
| [[AgentSignifier]] | an |
The |
| [[EventList]] | a |
Events are appended to the list during evaluation. |
| [[AgentSynchronizesWith]] | a |
A Chosen Value Record is a
| Field Name | Value | Meaning |
|---|---|---|
| [[Event]] | a |
The |
| [[ChosenValue]] | a |
The bytes that were nondeterministically chosen during evaluation. |
A candidate execution of the evaluation of an
| Field Name | Value | Meaning |
|---|---|---|
| [[EventsRecords]] | a |
Maps an |
| [[ChosenValues]] | a |
Maps |
| [[AgentOrder]] | an |
Defined below. |
| [[ReadsBytesFrom]] | a |
Defined below. |
| [[ReadsFrom]] | a |
Defined below. |
| [[HostSynchronizesWith]] | a |
Defined below. |
| [[SynchronizesWith]] | a |
Defined below. |
| [[HappensBefore]] | a |
Defined below. |
An empty candidate execution is a
candidate
execution
The abstract operation EventSet takes argument execution (a
The abstract operation SharedDataBlockEventSet takes argument execution (a
The abstract operation HostEventSet takes argument execution (a
The abstract operation ComposeWriteEventBytes takes arguments execution (a
The read-modify-write modification [[ModifyOp]] is given by the function
properties on the Atomics object that introduce
This abstract operation composes a
The abstract operation ValueOfReadEvent takes arguments execution (a
For a
Each
For a
For each
For a
For a
For two
The host-synchronizes-with relation allows the postMessage between HTML workers.
For a
Owing to convention, write events synchronizes-with read events, instead of read events synchronizes-with write events.
Not all
For
For a
Because happens-before is a superset of
A
A
A
An event's [[NoTear]] field is
Intuitively, this requirement says when a memory range is accessed in an aligned fashion via an
For a
For each pair (R, W) in execution.[[ReadsFrom]], there is no
This clause additionally constrains
For each
A
While memory-order includes all events in
A
All programs have at least one valid execution.
For an execution execution, two events E and D in
For an execution execution, two events E and D in
An execution execution is data race free if there are no two events in
A program is data race free if all its executions are data race free.
The
The following are guidelines for ECMAScript programmers working with shared memory.
We recommend programs be kept data race free, i.e., make it so that it is impossible for there to be
concurrent non-atomic operations on the same memory location. Data race free programs have
interleaving
semantics where each step in the evaluation semantics of each
More generally, even if a program is not data race free it may have predictable behaviour, so long as atomic operations are not involved in any data races and the operations that race all have the same access size. The simplest way to arrange for atomics not to be involved in races is to ensure that different memory cells are used by atomic and non-atomic operations and that atomic accesses of different sizes are not used to access the same cells at the same time. Effectively, the program should treat shared memory as strongly typed as much as possible. One still cannot depend on the ordering and timing of non-atomic accesses that race, but if memory is treated as strongly typed the racing accesses will not "tear" (bits of their values will not be mixed).
The following are guidelines for ECMAScript implementers writing compiler transformations for programs using shared memory.
It is desirable to allow most program transformations that are valid in a single-
Let an agent-order slice be the subset of the
Let possible read values of a read event be the set of all values of
Any transformation of an agent-order slice that is valid in the absence of shared memory is valid in the presence of shared memory, with the following exceptions.
Atomics are carved in stone: Program transformations must not cause the
(In practice, the prohibition on reorderings forces a compiler to assume that every
Reads must be stable: Any given shared memory read must only observe a single value in an execution.
(For example, if what is semantically a single read in the program is executed multiple times then the program is subsequently allowed to observe only one of the values read. A transformation known as rematerialization can violate this rule.)
Writes must be stable: All observable writes to shared memory must follow from program semantics in an execution.
(For example, a transformation may not introduce certain observable writes, such as by using
read-modify-write operations on a larger location to write a smaller datum, writing a value to
memory
that the program could not have written, or writing a just-read value back to the location it was
read
from, if that location could have been overwritten by another
Possible read values must be non-empty: Program transformations cannot cause the possible read values of a shared memory read to become empty.
(Counterintuitively, this rule in effect restricts transformations on writes, because writes have
force in
Examples of transformations that remain valid are: merging multiple non-atomic reads from the same
location, reordering non-atomic reads, introducing speculative non-atomic reads, merging multiple
non-atomic writes to the same location, reordering non-atomic writes to different locations, and
hoisting
non-atomic reads out of loops even if that affects termination. Note in general that aliased
The following are guidelines for ECMAScript implementers generating machine code for shared memory accesses.
For architectures with memory models no weaker than those of ARM or Power, non-atomic stores and
loads
may be compiled to bare stores and loads on the target architecture. Atomic stores and loads may be
compiled down to instructions that guarantee sequential consistency. If no such instructions exist,
memory
barriers are to be employed, such as placing barriers on both sides of a bare store or load.
Read-modify-write operations may be compiled to read-modify-write instructions on the target
architecture,
such as LOCK-prefixed instructions on x86, load-exclusive/store-exclusive instructions on
ARM, and load-link/store-conditional instructions on Power.
Specifically, the
Naive code generation uses these patterns:
That mapping is correct so long as an atomic operation on an address range does not race with a
non-atomic write or with an atomic operation of different size. However, that is all we need: the
Local improvements to those basic patterns are also allowed, subject to the constraints of the
LOCK-prefixed instructions. On many platforms there are fences of several strengths,
and
weaker fences can be used in certain contexts without destroying sequential consistency.
When processing an instance of the production
the interpretation of
When processing an instance of the production
the interpretation of
In certain circumstances when processing an instance of the production
the interpretation of
When processing an instance of the production
the interpretation of
When processing an instance of the production
the interpretation of
All grammar symbols not explicitly defined by the
Each \u u u \u
The ECMAScript language syntax and semantics defined in this annex are required when the ECMAScript
This annex describes various legacy features and other characteristics of web browser ECMAScript
These features are not considered part of the core ECMAScript language. Programmers should not use or assume the existence of these features and behaviours when writing new ECMAScript code. ECMAScript implementations are discouraged from implementing these features unless the implementation is part of a web browser or is required to run the same legacy ECMAScript code that web browsers encounter.
The syntax and semantics of
Similar to a
The syntax of
This alternative pattern grammar and semantics only changes the syntax and semantics of BMP patterns.
The
following grammar extensions include productions parameterized with the [UnicodeMode] parameter.
However,
none of these extensions change the syntax of Unicode patterns recognized when parsing with the
[UnicodeMode] parameter present on the
When the same left-hand sides occurs with both [+UnicodeMode] and [~UnicodeMode] guards it is to control the disambiguation priority.
The semantics of
Additionally, the rules for the following productions are modified with the addition of the highlighted text:
In the definitions of
The semantics of
The semantics of
The semantics of
The rule for
The rule for
The rule for
\ U+005C (REVERSE SOLIDUS).The semantics of
The following two rules replace the corresponding rules of
In addition, the following rules are added to
\ U+005C (REVERSE SOLIDUS).\c
within
a
character class where it is not followed by an acceptable control character.The abstract operation CharacterRangeOrUnion takes arguments rer (a
The semantics of
The abstract operation
When the ECMAScript
The entries in
| Intrinsic Name | Global Name | ECMAScript Language Association |
|---|---|---|
|
|
escape
|
The escape function ( |
|
|
unescape
|
The unescape function ( |
This function is a property of the
When replacing a code unit of numeric value less than or equal to 0x00FF, a two-digit escape sequence
of
the form %xx is used. When replacing a code unit of numeric value strictly
greater
than 0x00FF, a four-digit escape sequence of the form %uxxxx is used.
It is the %escape% intrinsic object.
It performs the following steps when called:
The encoding is partly based on the encoding described in RFC 1738, but the entire encoding specified in this standard is described above without regard to the contents of RFC 1738. This encoding does not reflect changes to RFC 1738 made by RFC 3986.
This function is a property of the escape function is replaced with the code unit that it represents.
It is the %unescape% intrinsic object.
It performs the following steps when called:
This method returns a
It performs the following steps when called:
This method is intentionally generic; it does not require that its
This method performs the following steps when called:
The abstract operation CreateHTML takes arguments string (an
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
The property
The initial value of the
The property
The initial value of the
The getFullYear method is preferred for nearly all purposes, because it avoids the
“year
2000 problem.”
This method performs the following steps when called:
The setFullYear method is preferred for nearly all purposes, because it avoids the
“year
2000 problem.”
This method performs the following steps when called:
The toUTCString method is preferred. This method is provided principally for
compatibility with old code.
The initial value of the
This method performs the following steps when called:
This method completely reinitializes the
Prior to ECMAScript 2015, the specification of
The
Prior to ECMAScript 2015, the ECMAScript specification did not define the occurrence of a
A function is declared and only referenced within a single block.
var declaration occurs within the
function code of g.
A function is declared and possibly used within a single
var declaration occurs within the
function code of g.
A function is declared and possibly used within a single block but also referenced within subsequent blocks.
var declaration occurs within the
function code of g.
The first use case is interoperable with the semantics of
ECMAScript 2015 interoperability for the second and third use cases requires the following extensions
to
the clause
If an ECMAScript implementation has a mechanism for reporting diagnostic warning messages, a warning
should
be produced when code contains a
During
During
During
The rules for the following production in
switch Statement Static Semantics: Early
ErrorsThe rules for the following production in
During
During
The following augments the
This production only applies when parsing
The content of subclause
The var declarations that bind a name that is also bound by the var declarations will assign to the corresponding catch parameter rather than the
var binding.
This modified behaviour also applies to var and function declarations
introduced
by
Step
Step
The following augments the
This production only applies when parsing
The
The
The
The
The
The
The
An [[IsHTMLDDA]] internal slot may exist on typeof
operator
Objects with an [[IsHTMLDDA]] internal slot are never created by this
specification. However, the document.all
object in web browsers is a document.all.
The following step replaces step
The following steps replace step
typeof OperatorThe following step replaces step typeof
The
The
The strict mode restriction and exceptions
implements, interface, let, package,
private,
protected, public, static, and yield are TypeError exception is thrown (arguments to the arguments object is
immutable and hence may not be the target of an assignment expression. (Function.prototype.apply and Function.prototype.call) do not coerce the passed
delete operator occurs within delete operator occurs within eval or arguments (See
[[HostDefined]] on
[[HostDefined]] on
[[HostDefined]] on
[[HostDefined]] on
[[HostSynchronizesWith]] on Candidate Executions: See
[[IsHTMLDDA]]: See
The
Preparation steps before, and cleanup steps after, invocation of
Any of the essential internal methods in
Any built-in objects and methods not defined within this specification, except as restricted in
Date.prototype.toString when the
/.
String.prototype.match and
String.prototype.replace
was incorrect for cases where the pattern argument was a RegExp value whose global flag is set.
The
previous specifications stated that for each attempt to match the pattern, if lastIndex did not
change, it should be incremented by 1. The correct behaviour is that lastIndex should be
incremented by 1 only if the pattern matched the empty String.
Array.prototype.sort. ECMAScript 2015 specifies that such as value is treated as if
Space_Separator (Zs) category
and
thus treated as whitespace in ECMAScript 2015, to be moved to the Format (Cf)
category
(as of Unicode 6.3.0). This causes whitespace-sensitive methods to behave differently. For example,
"\u180E".trim().length was 0 in previous editions, but 1 in
ECMAScript
2016 and later. Additionally, ECMAScript 2017 mandated always using the latest version of the Unicode
Standard.
let followed by the token [ is the start of a
( token of a for statement is immediately followed by the token sequence let [
then the let is treated as the start of a
let [ then the
let is treated as the start of a
in
var
declaration for the same
eval whose eval code includes a var or FunctionDeclaration
declaration
that binds the same
Object.freeze is not an object it is treated as if it was a non-extensible
Object.getOwnPropertyDescriptor is not an object an attempt
is
made to coerce the argument using
Object.getOwnPropertyNames is not an object an attempt is made to
coerce
the argument using
Object.getPrototypeOf is not an object an attempt is made to coerce the
argument
using
Object.isExtensible is not an object it is treated as if it was a
non-extensible
Object.isFrozen is not an object it is treated as if it was a non-extensible
Object.isSealed is not an object it is treated as if it was a non-extensible
Object.keys is not an object an attempt is made to coerce the argument using
Object.preventExtensions is not an object it is treated as if it was a
non-extensible
Object.seal is not an object it is treated as if it was a non-extensible
String.prototype.localeCompare function must treat Strings that are
canonically equivalent according to the Unicode Standard as being identical. In previous editions
implementations were permitted to ignore canonical equivalence and could instead use a bit-wise comparison.
String.prototype.trim method is defined to recognize white space code points that may exist
outside of the Unicode BMP. However, as of Unicode 7 no such code points are defined. In previous editions
such
code points would not have been recognized as white space.
Atomics.wake has been renamed to Atomics.notify to prevent confusion with
Atomics.wait.
await was reduced,
which could create an observable difference in resolution order between a then() call and an
await expression.
This specification is authored on GitHub in a plaintext source format called Ecmarkup. Ecmarkup is an HTML and Markdown dialect that provides a framework and toolset for authoring ECMAScript specifications in plaintext and processing the specification into a full-featured HTML rendering that follows the editorial conventions for this document. Ecmarkup builds on and integrates a number of other formats and technologies including Grammarkdown for defining syntax and Ecmarkdown for authoring algorithm steps. PDF renderings of this specification are produced by printing the HTML rendering to a PDF.
Prior editions of this specification were authored using Word—the Ecmarkup source text that formed the basis of this edition was produced by converting the ECMAScript 2015 Word document to Ecmarkup using an automated conversion tool.
There are no normative changes between IEEE 754-2008 and IEEE 754-2019 that affect the ECMA-262 specification.
Script Property, available at <https://unicode.org/reports/tr24/>
Ecma International
Rue du Rhone 114
CH-1204 Geneva
Tel: +41 22 849 6000
Fax: +41 22 849 6001
Web: https://ecma-international.org/
© 2024 Ecma International
By obtaining and/or copying this work, you (the licensee) agree that you have read, understood, and will comply with the following terms and conditions.
Permission under Ecma’s copyright to copy, modify, prepare derivative works of, and distribute this work, with or without modification, for any purpose and without fee or royalty is hereby granted, provided that you include the following on ALL copies of the work or portions thereof, including modifications:
Disclaimers
THIS WORK IS PROVIDED “AS IS,” AND COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE DOCUMENT WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS.
COPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE DOCUMENT.
The name and trademarks of copyright holders may NOT be used in advertising or publicity pertaining to the work without specific, written prior permission. Title to copyright in this work will at all times remain with copyright holders.
All Software contained in this document ("Software") is protected by copyright and is being made available under the "BSD License", included below. This Software may be subject to third party rights (rights from parties other than Ecma International), including patent rights, and no licenses under such third party rights are granted under this license even if the third party concerned is a member of Ecma International. SEE THE ECMA CODE OF CONDUCT IN PATENT MATTERS AVAILABLE AT https://ecma-international.org/memento/codeofconduct.htm FOR INFORMATION REGARDING THE LICENSING OF PATENT CLAIMS THAT ARE REQUIRED TO IMPLEMENT ECMA INTERNATIONAL STANDARDS.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
THIS SOFTWARE IS PROVIDED BY THE ECMA INTERNATIONAL "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ECMA INTERNATIONAL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.